Android MediaPlayer + GLSurfaceView 播放视频

概述

    在Android开辟中，使用OpenGL ES来渲染视频是一种常见的需求，尤其是在需要实现自定义的视频播放界面或者视频殊效时。联合MediaPlayer，我们可以实现一个功能强盛的视频播放器。以下是一个简单的示例，展示如安在Android应用中使用OpenGL ES和MediaPlayer播放当地视频。
    常规的视频播放方式有VideoView, MediaPlayer + SurfaceView / TextureView, 以TextureView为例, 它与OpenGL(GLSurfaceView)播放的一些比较:
TextureView的优缺点

• 长处：
  
  
  
  • 灵活性高：TextureView可以与其他View叠加使用，非常适合在复杂的视图层次结构中使用。
    
  • 硬件加速支持：由于它在硬件加速层进行渲染，其性能也较优。
    
  • 支持绘制操纵：可以从其他线程更新内容，适合用于播放视频、显示及时殊效等。
    
  
  
• 缺点：
  
  
  
  • 内存占用较高：TextureView的内部缓冲队列导致比SurfaceView使用更多的内存。
    
  • 在5.0以前在主线程渲染：在5.0版本之前，TextureView在主线程渲染，可能会导致性能题目。
    
  
  

OpenGL的优缺点

• 长处：
  
  
  
  • 高度定制化：OpenGL提供低级别的图形渲染接口，答应开辟者高度定制视频播放界面和殊效。
    
  • 性能优化：通过优化渲染代码，可以在一定程度上进步视频播放的服从和性能。
    
  
  
• 缺点：
  
  
  
  • 开辟复杂度较高：使用OpenGL需要编写大量的底层代码，包罗顶点着色器和片段着色器的编写，这增长了开辟的复杂度和难度。
    
  
  

    TextureView在灵活性、硬件加速支持和多线程更新方面具有优势，适合需要与其他视图交互的场景。而OpenGL则提供了更高的定制化程度，适合需要实现复杂图形结果的场景
实现

    梳理收集来的参考代码, 实现视频播放结果如下:

   GLVideoActivity.java

1. package com.ansondroider.sdktester.activity;
3. import android.media.MediaPlayer;
4. import android.opengl.GLSurfaceView;
5. import android.os.Bundle;
7. import com.ansondroider.acore.BaseActivity;
8. import com.ansondroider.sdktester.gl.GLVideoView;
10. import java.io.IOException;
12. public class GLVideoActivity extends BaseActivity {
13.     MediaPlayer mmp;
14.     GLVideoView glView;
15.     @Override
16.     protected void onCreate(Bundle savedInstanceState) {
17.         super.onCreate(savedInstanceState);
18.         glView = new GLVideoView(this);
19.         setContentView(glView);
20.     }
22.     @Override
23.     protected void onStart() {
24.         super.onStart();
25.         //postDelayed(new Runnable() {
26.         //    @Override
27.         //    public void run() {
28.                 mmp = new MediaPlayer();
29.                 try {
30.                     mmp.setDataSource("/sdcard/Movies/376463.mp4");
31.                     mmp.setOnPreparedListener(new MediaPlayer.OnPreparedListener() {
32.                         @Override
33.                         public void onPrepared(MediaPlayer mediaPlayer) {
34.                             glView.onVideoPrepared(mediaPlayer);
35.                         }
36.                     });
37.                     mmp.prepare();
38.                 } catch (IOException e) {
39.                     e.printStackTrace();
40.                 }
41.         //    }
42.         //}, 100);
44.     }
46.     @Override
47.     protected void onStop() {
48.         super.onStop();
49.         mmp.stop();
50.         mmp.release();
51.     }
52. }

复制代码

  GLVideoView.java

1. package com.ansondroider.sdktester.gl;
2. import android.content.Context;
3. import android.graphics.SurfaceTexture;
4. import android.media.MediaPlayer;
5. import android.opengl.GLES11Ext;
6. import android.opengl.GLES20;
7. import android.opengl.GLSurfaceView;
8. import android.opengl.Matrix;
9. import android.util.AttributeSet;
10. import android.util.Log;
11. import android.view.Surface;
13. import java.nio.ByteBuffer;
14. import java.nio.ByteOrder;
15. import java.nio.FloatBuffer;
17. import javax.microedition.khronos.egl.EGLConfig;
18. import javax.microedition.khronos.opengles.GL10;
19. /**
20. * @ProjectName: TheSimpllestplayer
21. * @Package: com.yw.thesimpllestplayer.renderview
22. * @ClassName: VideoDrawer
23. * @Description: 视频渲染器
24. * @Author: wei.yang
25. * @CreateDate: 2021/11/6 14:23
26. * @UpdateUser: 更新者：wei.yang
27. * @UpdateDate: 2021/11/6 14:23
28. * @UpdateRemark: 更新说明：
29. * @Version: 1.0
30. */
31. public class GLVideoView extends GLSurfaceView {
32.     final String TAG = "GLVideoView";
33.     //顶点坐标，此处的坐标系是物体坐标系：中心店坐标是（0,0）
34.     private float[] mVertexCoors = new float[]{
35.             -1f, -1f,
36.             1f, -1f,
37.             -1f, 1f,
38.             1f, 1f
39.     };
40.     //纹理坐标系，中心坐标点为（0.5,0.5），上方向为t从0~1，右边方向为s，从0~1.刚好和计算器物理坐标系是反过来的。
41.     private float[] mTextureCoors = new float[]{
42.             0f, 1f,
43.             1f, 1f,
44.             0f, 0f,
45.             1f, 0f
46.     };
47.     private String vertextShaderSource = "attribute vec4 aPosition;" +
48.             "precision mediump float;" +
49.             "uniform mat4 uMatrix;" +
50.             "attribute vec2 aCoordinate;" +
51.             "varying vec2 vCoordinate;" +
52.             "attribute float alpha;" +
53.             "varying float inAlpha;" +
54.             "void main(){" +
55.             "gl_Position = uMatrix*aPosition;" +
56.             "vCoordinate = aCoordinate;" +
57.             "inAlpha = alpha;" +
58.             "}";
59.     private String fragmentShaderSource = "#extension GL_OES_EGL_image_external : require\n" +
60.             "precision mediump float;" +
61.             "varying vec2 vCoordinate;" +
62.             "varying float inAlpha;" +
63.             "uniform samplerExternalOES uTexture;" +
64.             "void main() {" +
65.             "vec4 color = texture2D(uTexture, vCoordinate);" +
66.             "gl_FragColor = vec4(color.r, color.g, color.b, inAlpha);" +
67.             "}";
68.     //视频宽高
69.     private int mVideoWidth = -1;
70.     private int mVideoHeight = -1;
72.     //物理屏幕的宽高
73.     private int mWorldWidth = -1;
74.     private int mWorldHeight = -1;
76.     //纹理ID
77.     private int mTextureId = -1;
79.     //定义SurfaceTexture 为显示视频做准备;
80.     private SurfaceTexture mSurfaceTexture = null;
82.     // 定义OpenGL 程序ID
83.     private int mProgram = -1;
84.     //矩阵变换接受者（shader中）
85.     private int mVertexMatrixHandler = -1;
86.     //顶点坐标接收者
87.     private int mVertexPosHandler = -1;
88.     //纹理坐标接受者
89.     private int mTexturePosHandler = -1;
90.     //纹理接受者
91.     private int mTextureHandler = -1;
92.     //半透明值接受者
93.     private int mAlphaHandler = -1;
94.     //顶点缓冲
95.     private FloatBuffer mVertexBuffer = null;
96.     //纹理缓冲
97.     private FloatBuffer mTextureBuffer = null;
98.     //矩阵
99.     private float[] mMatrix = null;
100.     //透明度
101.     private float mAlpha = 1f;
102.     //旋转角度
103.     private float mWidthRatio = 1f;
104.     private float mHeightRatio = 1f;
105.     private int floatLength = 16;
107.     public GLVideoView(Context context) {
108.         super(context);
109.         init();
110.     }
112.     public GLVideoView(Context context, AttributeSet attrs) {
113.         super(context, attrs);
114.         init();
115.     }
117.     private void init(){
118.         setEGLContextClientVersion(2);
119.         setRenderer(new VideoRender());
120.         setRenderMode(RENDERMODE_WHEN_DIRTY);
121.         initPos();
122.     }
124.     /**
125.      * 初始化顶点坐标
126.      */
127.     private void initPos() {
128.         ByteBuffer vByteBuffer = ByteBuffer.allocateDirect(mVertexCoors.length * 4);
129.         vByteBuffer.order(ByteOrder.nativeOrder());
130.         //将坐标转换为floatbuffer，用以传给opengl程序
131.         mVertexBuffer = vByteBuffer.asFloatBuffer();
132.         mVertexBuffer.put(mVertexCoors);
133.         mVertexBuffer.position(0);
135.         ByteBuffer tByteBuffer = ByteBuffer.allocateDirect(mTextureCoors.length * 4);
136.         tByteBuffer.order(ByteOrder.nativeOrder());
137.         mTextureBuffer = tByteBuffer.asFloatBuffer();
138.         mTextureBuffer.put(mTextureCoors);
139.         mTextureBuffer.position(0);
140.     }
142.     /**
143.      * 初始化矩阵变换，主要是防止视频拉伸变形
144.      */
145.     private void initDefMatrix() {
146.         //Log.d(TAG, "initDefMatrix");
147.         if (mMatrix != null) return;
148.         if (mVideoWidth != -1 && mVideoHeight != -1 &&
149.                 mWorldWidth != -1 && mWorldHeight != -1) {
150.             mMatrix = new float[floatLength];
151.             float[] prjMatrix = new float[floatLength];
152.             float originRatio = mVideoWidth / (float) mVideoHeight;
153.             float worldRatio = mWorldWidth / (float) mWorldHeight;
154.             if (mWorldWidth > mWorldHeight) {
155.                 if (originRatio > worldRatio) {
156.                     mHeightRatio = originRatio / worldRatio;
157.                     Matrix.orthoM(
158.                             prjMatrix, 0,
159.                             -mWidthRatio, mWidthRatio,
160.                             -mHeightRatio, mHeightRatio,
161.                             3f, 5f
162.                     );
163.                 } else {// 原始比例小于窗口比例，缩放高度度会导致高度超出，因此，高度以窗口为准，缩放宽度
164.                     mWidthRatio = worldRatio / originRatio;
165.                     Matrix.orthoM(
166.                             prjMatrix, 0,
167.                             -mWidthRatio, mWidthRatio,
168.                             -mHeightRatio, mHeightRatio,
169.                             3f, 5f
170.                     );
171.                 }
172.             } else {
173.                 if (originRatio > worldRatio) {
174.                     mHeightRatio = originRatio / worldRatio;
175.                     Matrix.orthoM(
176.                             prjMatrix, 0,
177.                             -mWidthRatio, mWidthRatio,
178.                             -mHeightRatio, mHeightRatio,
179.                             3f, 5f
180.                     );
181.                 } else {// 原始比例小于窗口比例，缩放高度会导致高度超出，因此，高度以窗口为准，缩放宽度
182.                     mWidthRatio = worldRatio / originRatio;
183.                     Matrix.orthoM(
184.                             prjMatrix, 0,
185.                             -mWidthRatio, mWidthRatio,
186.                             -mHeightRatio, mHeightRatio,
187.                             3f, 5f
188.                     );
189.                 }
190.             }
191.             //设置相机位置
192.             float[] viewMatrix = new float[floatLength];
193.             Matrix.setLookAtM(
194.                     viewMatrix, 0,
195.                     0f, 0f, 5.0f,
196.                     0f, 0f, 0f,
197.                     0f, 1.0f, 0f
198.             );
199.             //计算变换矩阵
200.             Matrix.multiplyMM(mMatrix, 0, prjMatrix, 0, viewMatrix, 0);
201.         }
202.     }
203.     private Surface mSurface = null;
204.     MediaPlayer mMediaPlayer;
205.     public void onVideoPrepared(MediaPlayer mp){
206.         Log.d(TAG, "onVideoPrepared");
207.         mMediaPlayer = mp;
209.         if(mSurfaceTexture != null) {
210.             int videoWidth = mMediaPlayer.getVideoWidth();
211.             int videoHeight = mMediaPlayer.getVideoHeight();
212.             setVideoSize(videoWidth, videoHeight);
213.             mSurface = new Surface(mSurfaceTexture);
214.             mMediaPlayer.setSurface(mSurface);
215.             mMediaPlayer.start();
216.         }
217.     }
218.     private void setVideoSize(int videoWidth, int videoHeight) {
219.         Log.d(TAG, "setVideoSize " + videoWidth + "x" + videoHeight);
220.         mVideoWidth = videoWidth;
221.         mVideoHeight = videoHeight;
222.     }
224.     private void setWorldSize(int worldWidth, int worldHeight) {
225.         mWorldWidth = worldWidth;
226.         mWorldHeight = worldHeight;
227.     }
229.     @Override
230.     public void setAlpha(float alpha) {
231.         super.setAlpha(alpha);
232.         mAlpha = alpha;
233.     }
235.     private SurfaceTexture getSurfaceTexture() {
236.         return mSurfaceTexture;
237.     }
239.     /**
240.      * 创建并使用opengles程序
241.      */
242.     private void createGLPrg() {
243.         if (mProgram == -1) {
244.             int vertexShader = loadShader(GLES20.GL_VERTEX_SHADER, vertextShaderSource);
245.             int fragmentShader = loadShader(GLES20.GL_FRAGMENT_SHADER, fragmentShaderSource);
246.             //创建programe陈谷
247.             mProgram = GLES20.glCreateProgram();
248.             //将顶点着色器加入程序
249.             GLES20.glAttachShader(mProgram, vertexShader);
250.             //将片元着色器加入程序
251.             GLES20.glAttachShader(mProgram, fragmentShader);
252.             GLES20.glLinkProgram(mProgram);
253.             //从程序中获取句柄
254.             mVertexMatrixHandler = GLES20.glGetUniformLocation(mProgram, "uMatrix");
255.             mVertexPosHandler = GLES20.glGetAttribLocation(mProgram, "aPosition");
256.             mTextureHandler = GLES20.glGetUniformLocation(mProgram, "uTexture");
257.             mTexturePosHandler = GLES20.glGetAttribLocation(mProgram, "aCoordinate");
258.             mAlphaHandler = GLES20.glGetAttribLocation(mProgram, "alpha");
260.         }
261.         //使用opengl程序
262.         GLES20.glUseProgram(mProgram);
263.     }
265.     /**
266.      * 激活并绑定纹理单元
267.      */
268.     private void activateTexture() {
269.         //激活指定纹理单元
270.         GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
271.         //绑定纹理ID到纹理单元
272.         GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, mTextureId);
273.         //将激活并绑定的纹理id传递到着色器里面
274.         GLES20.glUniform1i(mTextureHandler, 0);
275.         //配置边缘过滤参数
276.         GLES20.glTexParameterf(
277.                 GLES11Ext.GL_TEXTURE_EXTERNAL_OES,
278.                 GLES20.GL_TEXTURE_MIN_FILTER,
279.                 GLES20.GL_LINEAR
280.         );
281.         GLES20.glTexParameterf(
282.                 GLES11Ext.GL_TEXTURE_EXTERNAL_OES,
283.                 GLES20.GL_TEXTURE_MAG_FILTER,
284.                 GLES20.GL_LINEAR
285.         );
286.         //配置s轴和t轴的方式
287.         GLES20.glTexParameteri(
288.                 GLES11Ext.GL_TEXTURE_EXTERNAL_OES,
289.                 GLES20.GL_TEXTURE_WRAP_S,
290.                 GLES20.GL_CLAMP_TO_EDGE
291.         );
292.         GLES20.glTexParameteri(
293.                 GLES11Ext.GL_TEXTURE_EXTERNAL_OES,
294.                 GLES20.GL_TEXTURE_WRAP_T,
295.                 GLES20.GL_CLAMP_TO_EDGE
296.         );
297.     }
299.     private void updateTexture() {
300.         mSurfaceTexture.updateTexImage();
301.     }
303.     /**
304.      * 加载着色器
305.      *
306.      * @param shaderType 着色器类型
307.      * @param shaderCode 着色器代码
308.      * @return
309.      */
310.     private int loadShader(int shaderType, String shaderCode) {
311.         //根据着色器类型创建着色器
312.         int shader = GLES20.glCreateShader(shaderType);
313.         //将着色其代码加入到着色器
314.         GLES20.glShaderSource(shader, shaderCode);
315.         //编译zhuoseq
316.         GLES20.glCompileShader(shader);
317.         return shader;
318.     }
320.     /**
321.      * 开始绘制渲染
322.      */
323.     public void doDraw() {
324.         if(mMatrix == null)return;
325.         //启用顶点坐标句柄
326.         GLES20.glEnableVertexAttribArray(mVertexPosHandler);
327.         GLES20.glEnableVertexAttribArray(mTexturePosHandler);
328.         GLES20.glUniformMatrix4fv(mVertexMatrixHandler, 1, false, mMatrix, 0);
329.         //设置着色器参数， 第二个参数表示一个顶点包含的数据数量，这里为xy，所以为2
330.         GLES20.glVertexAttribPointer(mVertexPosHandler, 2, GLES20.GL_FLOAT, false, 0, mVertexBuffer);
331.         GLES20.glVertexAttribPointer(
332.                 mTexturePosHandler,
333.                 2,
334.                 GLES20.GL_FLOAT,
335.                 false,
336.                 0,
337.                 mTextureBuffer
338.         );
339.         GLES20.glVertexAttrib1f(mAlphaHandler, mAlpha);
340.         //开始绘制
341.         GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, mVertexCoors.length / 2);
342.     }
344.     @Override
345.     protected void onDetachedFromWindow() {
346.         Log.d(TAG, "onDetachedFromWindow");
347.         super.onDetachedFromWindow();
348.         GLES20.glDisableVertexAttribArray(mVertexPosHandler);
349.         GLES20.glDisableVertexAttribArray(mTexturePosHandler);
350.         GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, 0);
351.         GLES20.glDeleteTextures(1, new int[]{mTextureId}, 0);
352.         GLES20.glDeleteProgram(mProgram);
353.         if(mMediaPlayer != null){
354.             //mMediaPlayer.setSurface(null);
355.             mMediaPlayer.release();
356.             mSurface.release();
357.         }
358.     }
360.     public void translate(float dx, float dy) {
361.         Matrix.translateM(mMatrix, 0, dx * mWidthRatio * 2, -dy * mHeightRatio * 2, 0f);
362.     }
364.     public void scale(float sx, float sy) {
365.         Matrix.scaleM(mMatrix, 0, sx, sy, 1f);
366.         mWidthRatio /= sx;
367.         mHeightRatio /= sy;
368.     }
370.     public class VideoRender implements GLSurfaceView.Renderer {
371.         @Override
372.         public void onSurfaceCreated(GL10 gl, EGLConfig config) {
373.             Log.d(TAG, "onSurfaceCreated");
374.             GLES20.glClearColor(0f, 0f, 0f, 0f);
375.             //开启混合，即半透明
376.             GLES20.glEnable(GLES20.GL_BLEND);
377.             GLES20.glBlendFunc(GLES20.GL_SRC_ALPHA, GLES20.GL_ONE_MINUS_SRC_ALPHA);
378.             int[] textureIds = new int[1];
379.             GLES20.glGenTextures(1, textureIds, 0);
380.             mTextureId = textureIds[0];
381.             //根据textureId初始化一个SurfaceTexture
382.             mSurfaceTexture = new SurfaceTexture(mTextureId);
383.             mSurfaceTexture.setOnFrameAvailableListener(new SurfaceTexture.OnFrameAvailableListener() {
384.                 @Override
385.                 public void onFrameAvailable(SurfaceTexture surfaceTexture) {
386.                     requestRender();
387.                 }
388.             });
389.             if(mMediaPlayer != null){
390.                 onVideoPrepared(mMediaPlayer);
391.             }
392.         }
394.         @Override
395.         public void onSurfaceChanged(GL10 gl, int width, int height) {
396.             Log.d(TAG, "onSurfaceChanged");
397.             GLES20.glViewport(0, 0, width, height);
398.             setWorldSize(width, height);
399.         }
401.         @Override
402.         public void onDrawFrame(GL10 gl) {
403.             Log.d(TAG, "onDrawFrame");
404.             if(mMediaPlayer == null || !mMediaPlayer.isPlaying())return;
406.             //清除颜色缓冲和深度缓冲
407.             GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT | GLES20.GL_DEPTH_BUFFER_BIT);
408.             if (mTextureId != -1) {
409.                 initDefMatrix();
410.                 //2/创建、编译、启动opengles着色器
411.                 createGLPrg();
412.                 //3.激活并绑定纹理单元
413.                 activateTexture();
414.                 //4.绑定图元到纹理单元
415.                 updateTexture();
416.                 //5.开始绘制渲染
417.                 doDraw();
418.             }
419.         }
420.     }
421. }

复制代码

复杂图形结果的场景

平凡的视频播放方式很难实现 曲面 百叶窗 这类的结果, 如:

而使用OpenGL播放, 只需要调整下顶点和纹理的坐标即可:

1.     //顶点坐标，此处的坐标系是物体坐标系：中心店坐标是（0,0）
2.     private float[] mVertexCoors = new float[]{
3.             -1f, 1f,
4.             -1f, -1f,
5.             0, 0.5f,
6.             0, -0.5f,
7.             1f, 1f,
8.             1f, -1f,
9.     };
10.     //纹理坐标系，中心坐标点为（0.5,0.5），上方向为t从0~1，右边方向为s，从0~1.刚好和计算器物理坐标系是反过来的。
11.     private float[] mTextureCoors = new float[]{
12.             0f, 0f,
13.             0f, 1f,
14.             0.5f, 0,
15.             0.5f, 1f,
16.             1f, 0f,
17.             1f, 1f
18.     };

复制代码

参考

• 10.GLSurfaceView+MediaPlayer播放视频.md
  
• 【Android 音视频开辟打怪升级：OpenGL渲染视频画面篇】二、使用OpenGL渲染视频画面
  
• Android 最简单的视频播放器之OpenGL ES视频渲染工具封装（三）
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。