android opengl播放全景视频

最新推荐文章于 2024-05-11 20:35:09 发布
最新推荐文章于 2024-05-11 20:35:09 发布
阅读量598 收藏 1
点赞数

android opengl播放全景视频

原理是opengl显示全景图片和opengl播放视频的结合，下面是代码

import android.app.Activity;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.SurfaceTexture;
import android.media.AudioManager;
import android.media.MediaPlayer;
import android.opengl.GLES11Ext;
import android.opengl.GLES20;
import android.opengl.GLSurfaceView;
import android.opengl.GLUtils;
import android.opengl.Matrix;
import android.os.Bundle;
import android.os.Environment;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.view.MotionEvent;
import android.view.Surface;

import android.view.ViewGroup;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.FloatBuffer;


import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.opengles.GL10;



import static android.opengl.GLES11Ext.GL_TEXTURE_EXTERNAL_OES;

/**
 * Created by Administrator on 2016/8/31 0031.
 */
public class VideoActivity extends Activity {
    GLSurfaceView glSurfaceView;
    public float mAngleX = 0;// 摄像机所在的x坐标
    public float mAngleY = 0;// 摄像机所在的y坐标
    public float mAngleZ = 1;// 摄像机所在的z坐标

    public static String VL = "uniform mat4 uMVPMatrix;" +
            "attribute vec4 vPosition;" +
            "attribute vec2 a_texCoord;" +
            "varying vec2 v_texCoord;" +
            "void main() {" +
            "  gl_Position = uMVPMatrix * vPosition;" +
            "  v_texCoord = a_texCoord;" +
            "}";
    public static String FL = "#extension GL_OES_EGL_image_external : require\n" +
            "precision mediump float;" +
            "varying vec2 v_texCoord;" +
            "uniform samplerExternalOES s_texture;" +

            "void main() {" +
            "  gl_FragColor = texture2D( s_texture, v_texCoord );" +
            "}";

    MediaPlayer mediaPlayerWrapper;
    RenderListener renderer;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        glSurfaceView = new GLSurfaceView(this);
        glSurfaceView.setLayoutParams(new ViewGroup.LayoutParams(-1, -1));
        setContentView(glSurfaceView);
        glSurfaceView.setEGLContextClientVersion(2);
        renderer = new RenderListener();
        glSurfaceView.setRenderer(renderer);
        glSurfaceView.setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY);
        new Thread(new Runnable() {
            @Override
            public void run() {

                mediaPlayerWrapper = new MediaPlayer();
                //mediaPlayerWrapper.init();
                mediaPlayerWrapper.setOnPreparedListener(new MediaPlayer.OnPreparedListener() {
                    @Override
                    public void onPrepared(MediaPlayer mp) {
                        mp.start();
                    }
                });

                mediaPlayerWrapper.setAudioStreamType(AudioManager.STREAM_MUSIC);
                mediaPlayerWrapper.setSurface(renderer.getSurface());

                try {
                    mediaPlayerWrapper.setDataSource(Environment.getExternalStorageDirectory().getAbsolutePath() + "/UPDATE/123_md360.mp4");
                    mediaPlayerWrapper.prepareAsync();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }

    float startRawX;
    float startRawY;

    double xFlingAngle;
    double xFlingAngleTemp;

    double yFlingAngle;
    double yFlingAngleTemp;

    @Override
    public boolean onTouchEvent(MotionEvent me) {
        //处理手指滑动事件，我这里的处理是判断手指在横向和竖向滑动的距离
        //这个距离隐射到球体上经度和纬度的距离，根据这个距离计算三维空间的两个
        //夹角，根据这个夹角调整摄像机所在位置
        if (me.getAction() == MotionEvent.ACTION_DOWN) {
            startRawX = me.getRawX();
            startRawY = me.getRawY();
        } else if (me.getAction() == MotionEvent.ACTION_MOVE) {

            float distanceX = startRawX - me.getRawX();
            float distanceY = startRawY - me.getRawY();

            //这里的0.1f是为了不上摄像机移动的过快
            distanceY = 0.1f * (distanceY) / getWindowManager().getDefaultDisplay().getHeight();

            yFlingAngleTemp = distanceY * 180 / (Math.PI * 3);

            if (yFlingAngleTemp + yFlingAngle > Math.PI / 2) {
                yFlingAngleTemp = Math.PI / 2 - yFlingAngle;
            }
            if (yFlingAngleTemp + yFlingAngle < -Math.PI / 2) {
                yFlingAngleTemp = -Math.PI / 2 - yFlingAngle;
            }
            //这里的0.1f是为了不上摄像机移动的过快
            distanceX = 0.1f * (-distanceX) / getWindowManager().getDefaultDisplay().getWidth();
            xFlingAngleTemp = distanceX * 180 / (Math.PI * 3);


            mAngleX = (float) (Math.cos(yFlingAngle + yFlingAngleTemp) * Math.sin(xFlingAngle + xFlingAngleTemp));

            mAngleY = -(float) (Math.sin(yFlingAngle + yFlingAngleTemp));


            mAngleZ = (float) (Math.cos(yFlingAngle + yFlingAngleTemp) * Math.cos(xFlingAngle + xFlingAngleTemp));

            glSurfaceView.requestRender();
        } else if (me.getAction() == MotionEvent.ACTION_UP) {
            xFlingAngle += xFlingAngleTemp;
            yFlingAngle += yFlingAngleTemp;
        }
        return true;
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        if (mediaPlayerWrapper != null)
            mediaPlayerWrapper.release();
    }

    @Override
    protected void onPause() {
        super.onPause();
        if (mediaPlayerWrapper != null)
            mediaPlayerWrapper.pause();
    }

    @Override
    protected void onResume() {
        super.onResume();
        if (mediaPlayerWrapper != null)
            mediaPlayerWrapper.start();
    }
    class RenderListener implements GLSurfaceView.Renderer {

        FloatBuffer verticalsBuffer;

        int CAP = 9;//绘制球体时，每次增加的角度
        float[] verticals = new float[(180 / CAP) * (360 / CAP) * 6 * 3];


        private final FloatBuffer mUvTexVertexBuffer;

        private final float[] UV_TEX_VERTEX = new float[(180 / CAP) * (360 / CAP) * 6 * 2];

        private int mProgram;
        private int mPositionHandle;
        private int mTexCoordHandle;
        private int mMatrixHandle;
        private int mTexSamplerHandle;


        private final float[] mProjectionMatrix = new float[16];
        private final float[] mCameraMatrix = new float[16];
        private final float[] mMVPMatrix = new float[16];


        private int[] mTexNames;

        private SurfaceTexture surfaceTexture;
        private boolean isAvailiable;
        public Surface surface;
        float r = 6f;//球体半径
        public RenderListener() {

            float x = 0;
            float y = 0;
            float z = 0;


            int index = 0;
            int index1 = 0;
            double d = CAP * Math.PI / 180;//每次递增的弧度
            for (int i = 0; i < 180; i += CAP) {
                double d1 = i * Math.PI / 180;
                for (int j = 0; j < 360; j += CAP) {
                    //获得球体上切分的超小片矩形的顶点坐标（两个三角形组成，所以有六点顶点）
                    double d2 = j * Math.PI / 180;
                    verticals[index++] = (float) (x + r * Math.sin(d1 + d) * Math.cos(d2 + d));
                    verticals[index++] = (float) (y + r * Math.cos(d1 + d));
                    verticals[index++] = (float) (z + r * Math.sin(d1 + d) * Math.sin(d2 + d));
                    //获得球体上切分的超小片三角形的纹理坐标
                    UV_TEX_VERTEX[index1++] = (j + CAP) * 1f / 360;
                    UV_TEX_VERTEX[index1++] = (i + CAP) * 1f / 180;

                    verticals[index++] = (float) (x + r * Math.sin(d1) * Math.cos(d2));
                    verticals[index++] = (float) (y + r * Math.cos(d1));
                    verticals[index++] = (float) (z + r * Math.sin(d1) * Math.sin(d2));

                    UV_TEX_VERTEX[index1++] = j * 1f / 360;
                    UV_TEX_VERTEX[index1++] = i * 1f / 180;

                    verticals[index++] = (float) (x + r * Math.sin(d1) * Math.cos(d2 + d));
                    verticals[index++] = (float) (y + r * Math.cos(d1));
                    verticals[index++] = (float) (z + r * Math.sin(d1) * Math.sin(d2 + d));

                    UV_TEX_VERTEX[index1++] = (j + CAP) * 1f / 360;
                    UV_TEX_VERTEX[index1++] = i * 1f / 180;

                    verticals[index++] = (float) (x + r * Math.sin(d1 + d) * Math.cos(d2 + d));
                    verticals[index++] = (float) (y + r * Math.cos(d1 + d));
                    verticals[index++] = (float) (z + r * Math.sin(d1 + d) * Math.sin(d2 + d));

                    UV_TEX_VERTEX[index1++] = (j + CAP) * 1f / 360;
                    UV_TEX_VERTEX[index1++] = (i + CAP) * 1f / 180;

                    verticals[index++] = (float) (x + r * Math.sin(d1 + d) * Math.cos(d2));
                    verticals[index++] = (float) (y + r * Math.cos(d1 + d));
                    verticals[index++] = (float) (z + r * Math.sin(d1 + d) * Math.sin(d2));

                    UV_TEX_VERTEX[index1++] = j * 1f / 360;
                    UV_TEX_VERTEX[index1++] = (i + CAP) * 1f / 180;

                    verticals[index++] = (float) (x + r * Math.sin(d1) * Math.cos(d2));
                    verticals[index++] = (float) (y + r * Math.cos(d1));
                    verticals[index++] = (float) (z + r * Math.sin(d1) * Math.sin(d2));

                    UV_TEX_VERTEX[index1++] = j * 1f / 360;
                    UV_TEX_VERTEX[index1++] = i * 1f / 180;


                }
            }
            verticalsBuffer = ByteBuffer.allocateDirect(verticals.length * 4)
                    .order(ByteOrder.nativeOrder())
                    .asFloatBuffer()
                    .put(verticals);
            verticalsBuffer.position(0);


            mUvTexVertexBuffer = ByteBuffer.allocateDirect(UV_TEX_VERTEX.length * 4)
                    .order(ByteOrder.nativeOrder())
                    .asFloatBuffer()
                    .put(UV_TEX_VERTEX);
            mUvTexVertexBuffer.position(0);
        }

        private Surface getSurface() {
            if (surface != null) {
                return surface;
            }
            int externalTextureId = -1;
            mTexNames = new int[1];

            GLES20.glGenTextures(1, mTexNames, 0);
            externalTextureId = mTexNames[0];

            GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
            GLES20.glBindTexture(
                    GL_TEXTURE_EXTERNAL_OES,
                    externalTextureId);
            GLES20.glTexParameterf(
                    GLES11Ext.GL_TEXTURE_EXTERNAL_OES,
                    GLES20.GL_TEXTURE_MIN_FILTER,
                    GLES20.GL_LINEAR);
            GLES20.glTexParameterf(
                    GLES11Ext.GL_TEXTURE_EXTERNAL_OES,
                    GLES20.GL_TEXTURE_MAG_FILTER,
                    GLES20.GL_LINEAR);
            GLES20.glTexParameteri(
                    GLES11Ext.GL_TEXTURE_EXTERNAL_OES,
                    GLES20.GL_TEXTURE_WRAP_S,
                    GLES20.GL_CLAMP_TO_EDGE);
            GLES20.glTexParameteri(
                    GLES11Ext.GL_TEXTURE_EXTERNAL_OES,
                    GLES20.GL_TEXTURE_WRAP_T,
                    GLES20.GL_CLAMP_TO_EDGE);


            surfaceTexture = new SurfaceTexture(externalTextureId);
            surfaceTexture.setDefaultBufferSize(100, 100);
            surfaceTexture.setOnFrameAvailableListener(
                    new SurfaceTexture.OnFrameAvailableListener() {
                        @Override
                        public void onFrameAvailable(SurfaceTexture surfaceTexture) {
                            isAvailiable = true;
                            glSurfaceView.requestRender();
                        }
                    });

            surface = new Surface(surfaceTexture);
            return surface;
        }

        @Override
        public void onSurfaceCreated(GL10 gl, EGLConfig config) {
            getSurface();
        }

        @Override
        public void onSurfaceChanged(GL10 gl, int width, int height) {


            mProgram = GLES20.glCreateProgram();

            int vertexShader = GLES20.glCreateShader(GLES20.GL_VERTEX_SHADER);
            GLES20.glShaderSource(vertexShader, VL);
            GLES20.glCompileShader(vertexShader);

            int fragmentShader = GLES20.glCreateShader(GLES20.GL_FRAGMENT_SHADER);
            GLES20.glShaderSource(fragmentShader, FL);
            GLES20.glCompileShader(fragmentShader);

            GLES20.glAttachShader(mProgram, vertexShader);
            GLES20.glAttachShader(mProgram, fragmentShader);

            GLES20.glLinkProgram(mProgram);

            mPositionHandle = GLES20.glGetAttribLocation(mProgram, "vPosition");
            mTexCoordHandle = GLES20.glGetAttribLocation(mProgram, "a_texCoord");
            mMatrixHandle = GLES20.glGetUniformLocation(mProgram, "uMVPMatrix");
            mTexSamplerHandle = GLES20.glGetUniformLocation(mProgram, "s_texture");


            if(width<height){
                float ratio = height*1f / width;
                Matrix.frustumM(mProjectionMatrix, 0, -1, 1 ,-ratio, ratio,1f, 1000f);
            }else{
                float ratio =  width*1f / height;
                Matrix.perspectiveM(mProjectionMatrix, 0, 70f, ratio, 1, 1000f);
            }
        }

        @Override
        public void onDrawFrame(GL10 gl) {
            if (isAvailiable) {
                surfaceTexture.updateTexImage();
                isAvailiable = false;
            }
            //调整摄像机焦点位置，使画面滚动
            Matrix.setLookAtM(mCameraMatrix, 0, 0, 0, 0, mAngleX, mAngleY, mAngleZ, 0, 1, 0);

            Matrix.multiplyMM(mMVPMatrix, 0, mProjectionMatrix, 0, mCameraMatrix, 0);

            GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT | GLES20.GL_DEPTH_BUFFER_BIT);
            GLES20.glUseProgram(mProgram);
            GLES20.glEnableVertexAttribArray(mPositionHandle);
            GLES20.glVertexAttribPointer(mPositionHandle, 3, GLES20.GL_FLOAT, false,
                    12, verticalsBuffer);
            GLES20.glEnableVertexAttribArray(mTexCoordHandle);
            GLES20.glVertexAttribPointer(mTexCoordHandle, 2, GLES20.GL_FLOAT, false, 0,
                    mUvTexVertexBuffer);
            GLES20.glUniformMatrix4fv(mMatrixHandle, 1, false, mMVPMatrix, 0);
            GLES20.glUniform1i(mTexSamplerHandle, 0);


            GLES20.glDrawArrays(GLES20.GL_TRIANGLES, 0, (180 / CAP) * (360 / CAP) * 6);

            GLES20.glDisableVertexAttribArray(mPositionHandle);

        }
    }
}

作者：tenny1109
链接：https://www.jianshu.com/p/254837f663c4
來源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。
空间维度
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
openGL之API学习（一五一）全景视频、全景漫游
hankern的专栏
06-27 1085
b站上有很多类似的视频： https://www.bilibili.com/video/BV1NC4y1x75f?from=search&seid=14957294724232429514 https://www.bilibili.com/video/BV1zK41157zJ?from=search&seid=14957294724232429514 https://www.bilibili.com/video/BV11i4y1t74h?from=search&seid=149
android 封装 opengl,Android中如何使用OpenGL播放视频
weixin_39849239的博客
05-26 611
视频播放流程视频播放主要经历这么几个步骤：解协议 ->解封装 -> 解码音视频->音视频同步，流程如下图： 其中播放网络视频才需要解协议，直接播放本地视频是不需要这一步的解协议：将流媒体协议的数据解析为相应标准的封装格式数据。音视频在网络上进行传播的时候，通常会采用各种流媒体协议，如HTTP，RTMP等，这些协议在传输音视频数据的同时会增加一些信令信息(播放状态，网络状态描...
Android移动开发-VR全景照片简单实现
最新发布
2401_84901213的博客
05-11 585
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此我收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点！
Android openGL+MediaPlayer播放视频
lilinwang1990的博客
10-17 1481
Android平台，openGL + MediaPlayer实现视频播放
Android平台OpenGL实现全景图片视频播放
Contex_A17的博客
03-01 1270
Android平台OpenGL ES实现全景图片和视频播放
android全景图片视频
11-15
1. 视频编码与解码：Android系统内置了多种视频编码和解码器，如硬件加速的MediaCodec API，用于处理全景视频的编码、解码和播放。 2. 360°视频处理：处理全景视频时，需要处理每一帧的全景图像，将其转化为适合在...
Android全景视频播放器 源代码
11-13
3. **OpenGL ES**：在Android平台上，全景视频的渲染通常依赖于OpenGL ES（OpenGL for Embedded Systems），这是一个针对嵌入式系统的图形库，特别适合移动设备。OpenGL ES支持三维图形绘制，对于构建全景视频播放器...
Android平台下的全景视频播放器配套教程——1.3 用OpenGL ES 2.0显示一张图片
01-12
在Android平台上开发全景视频播放器是一项技术挑战，尤其是在处理图像渲染方面。本教程将深入探讨如何利用OpenGL ES 2.0这一强大的图形处理接口来显示一张全景图片，为全景视频播放器的构建打下基础。 首先，理解...
opengl es 全景显示模式触屏操作示例demo
04-30
opengl es 全景显示模式示例demo 分球内显示和球外显示的触屏操作
Android360度VR全景播放
12-19
在Android平台上实现360度VR全景播放是一项技术性较强的工作，涉及到虚拟现实（Virtual Reality，简称VR）技术与移动开发的结合。本知识点将详细讲解如何在Android应用中创建并实现360度VR全景视频或图像的播放功能...
基于ffmpeg和opengl的全景视频播放
11-06
能播放主流格式的全景视频，只需配置好opengl的环境，ffmpeg是直接嵌入在工程里面的，移动键盘上的上下左右按键可以旋转观看视角。前段时间发现好像少了几个库，需要的可以联系我qq820209232
android开发实战（VR技术360°全景播放视频）
06-22
android开发实战 ，vr技术360°全景播放视频
基于OpenGL的全景视频播放
03-04
基于OpenGL的全景视频播放，可用于播放全景视频，只要配置好OIpenGl就ok
Android 三维全景图片展示 PanoramaGL 源码
01-29
Android 三维全景图片展示 PanoramaGL 源码 , 亲测，可以用，可以考虑加入传感器，重力感应，进行全景图片的展示。
Android实现图片360度全景
11-10
Android实现图片360度全景
[OpenGL]从零开始写一个Android平台下的全景视频播放器——3.1 全景视频是如何实现的
Martin的博客
12-17 7757
Github项目地址为了方便没有准备好梯子的同学，我把项目在CSDN上打包下载，不过更新会慢一些回到目录恭喜Martin同学获得由CSDN颁发的“更新慢慢慢”荣誉称号全景视频有很多种类，例如Sphere全景，Skybox（Cubemap），Cylinder等，我们以最为常见的Sphere全景视频为例进行说明。原理其实要说明这个问题，只需要几张图 360全景视频截图 仔细观察我们会发现，视频的底
使用Android的OpenGL编写视频播放器
何晓龙的博客
03-08 1935
Android自身有MediaPlayer播放器，为什么还要使用OpenGL？因为使用OpenGL可以实现更多的效果，比如对视频翻转一定角度，加任意特效，多视频合并播放等，类似“激萌”的APP应该就是这样做的；相比之下，直接调用MediaPlayer的功能就少太多了。 　　OpenGL ES剔除了OpenGL中四边形和多边形的部分，即ES版本只支持三角形的绘制。使用分为三个步骤： 创建GL
Android OpenGL使用GLSurfaceView预览视频
热门推荐
K-night的专栏
03-19 2万+
前言一年之前做过一些即时通信视频相关的工作，主要是做视频渲染这一部分的工作，由于2016毕业来到了华为，华为对研究生的安排就是“哪里需要去哪里”，和你专业和擅长的没有太大的关系，所以一直在适应当下的工作，现在基本上可以胜任现在的工作，可以抽出一些时间来总结一下之前了解过的OpenGL相关知识。第一章 相关知识介绍在介绍具体的功能之前，先对一些主要的类和方法进行一些介绍，这样可以更好的理解整个程序1.
openglwidget 播放视频
11-15
虽然OpenGLWidget本身并不是用来播放视频的，但我们可以利用它来实现视频播放。 首先，我们需要加载一个视频文件。我们可以使用一些第三方库来实现，比如FFmpeg。通过FFmpeg，我们可以解码视频文件，并获取每一帧的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值