android vlc集成以及了解vlc架构

最新推荐文章于 2024-07-30 02:04:49 发布
最新推荐文章于 2024-07-30 02:04:49 发布
阅读量3.6k 收藏 9
点赞数 5
分类专栏： Android学习 文章标签： android java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-NC-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaweilihai/article/details/107232497
版权

一、近期整理了下之前用过的vlc for android；相关代码下载以及编译可以参考官方WIKI

官方Code下载地址，参考Git

个人Demo地址链接

https://github.com/xiaxiaxa/mgtv_vlc_demo：
在这里插入图片描述

二、搭建编译环境，编译vlc生成apk以及相对应的解码库等；

在ubuntu 14.04下面搭建编译环境，安装相关编译工具等；
下载代码：
git clone https://code.videolan.org/videolan/vlc-android.git
在这里插入图片描述在这里插入图片描述

需要配置NDK、JDK等环境变量等：
在这里插入图片描述
ubuntu相关交叉编译工具等可以使用附件sh自动安装

链接: https://pan.baidu.com/s/10s1aoF_SHacT9rEsueJP_A
提取码: aja2

超级用户下，直接运行脚本会安装对应的arm交叉编译工具等；

对应的编译模块以及相关命令：

编译模块命令生成路径
编译apksh compile.sh -a armeabi-v7avlc-android/build/outputs/apk/vanillaARMv7/debug
编译aarsh compile.sh -l -a armeabi-v7a -rlibvlc/build/outputs/aar
编译sosh compile-libvlc.sh -a armeabi-v7alibvlc/private_libs/libs/armeabi-v7a

在这里插入图片描述
aar里面的是libvlc编译出来的相关so库
在这里插入图片描述
个人编译的相关库以及vlc apk上传至网盘

提取码: h5hv

在这里插入图片描述

三、附上个人的Git使用demo，测试rtp/rtsp等直播流是没问题的；（个人主要用vlc来解决直播rtsp等播放问题）

public class VlcPlayActivity extends AppCompatActivity implements 
IVLCVout.OnNewVideoLayoutListener {

private static final boolean ENABLE_SUBTITLES = true;
    private static final String TAG = "VlcActivity";
    public static String SAMPLE_URL = "rtp://239.76.245.115:1234";
    private static final int SURFACE_BEST_FIT = 0;
    private static final int SURFACE_FIT_SCREEN = 1;
    private static final int SURFACE_FILL = 2;
    private static final int SURFACE_16_9 = 3;
    private static final int SURFACE_4_3 = 4;
    private static final int SURFACE_ORIGINAL = 5;
    private static int CURRENT_SIZE = SURFACE_BEST_FIT;
    private FrameLayout mVideoSurfaceFrame = null;
    private SurfaceView mVideoSurface = null;
    private SurfaceView mSubtitlesSurface = null;
    private final Handler mHandler = new Handler();
    private View.OnLayoutChangeListener mOnLayoutChangeListener = null;
    private LibVLC mLibVLC = null;
    private MediaPlayer mMediaPlayer = null;
    private int mVideoHeight = 0;
    private int mVideoWidth = 0;
    private int mVideoVisibleHeight = 0;
    private int mVideoVisibleWidth = 0;
    private int mVideoSarNum = 0;
    private int mVideoSarDen = 0;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        setContentView(R.layout.vlc_play);
        SAMPLE_URL = getIntent().getStringExtra("extra_url");
        final ArrayList<String> args = new ArrayList<>();
        args.add("-vvv");
        mLibVLC = new LibVLC(this, args);
        mMediaPlayer = new MediaPlayer(mLibVLC);

        mVideoSurfaceFrame = (FrameLayout) findViewById(R.id.video_surface_frame);
        mVideoSurface = (SurfaceView) findViewById(R.id.video_surface);
        if (ENABLE_SUBTITLES) {
            final ViewStub stub = (ViewStub) findViewById(R.id.subtitles_stub);
            mSubtitlesSurface = (SurfaceView) stub.inflate();
            mSubtitlesSurface.setZOrderMediaOverlay(true);
            mSubtitlesSurface.getHolder().setFormat(PixelFormat.TRANSLUCENT);
        }
    }

    @Override
    protected void onPause() {
        super.onPause();
        releaseData();
    }


    @Override
    protected void onDestroy() {
        super.onDestroy();
        releaseData();
    }

    private void releaseData() {

        if (isFinishing()) {
            if (mOnLayoutChangeListener != null) {
                if (mVideoSurfaceFrame != null) {
                    mVideoSurfaceFrame.removeOnLayoutChangeListener(mOnLayoutChangeListener);
                }
                mOnLayoutChangeListener = null;
            }
            if (mMediaPlayer != null) {
                mMediaPlayer.getVLCVout().detachViews();
                mMediaPlayer.pause();
                mMediaPlayer.stop();
                mMediaPlayer.release();
                mMediaPlayer = null;
            }

            if (mSubtitlesSurface != null) {
                mSubtitlesSurface = null;
            }

            if (mHandler != null) {
                mHandler.removeCallbacks(null);
            }

        }
    }

    @Override
    protected void onStart() {
        super.onStart();
        final IVLCVout vlcVout = mMediaPlayer.getVLCVout();
        vlcVout.setVideoView(mVideoSurface);
        if (mSubtitlesSurface != null)
            vlcVout.setSubtitlesView(mSubtitlesSurface);
        vlcVout.attachViews(this);

        Media media = new Media(mLibVLC, Uri.parse("rtp://239.76.245.115:1234"));
        mMediaPlayer.setMedia(media);
        media.release();
        mMediaPlayer.play();

        if (mOnLayoutChangeListener == null) {
            mOnLayoutChangeListener = new View.OnLayoutChangeListener() {
                private final Runnable mRunnable = new Runnable() {
                    @Override
                    public void run() {
                        updateVideoSurfaces();
                    }
                };

                @Override
                public void onLayoutChange(View v, int left, int top, int right,
                                           int bottom, int oldLeft, int oldTop, int oldRight, int oldBottom) {
                    if (left != oldLeft || top != oldTop || right != oldRight || bottom != oldBottom) {
                        mHandler.removeCallbacks(mRunnable);
                        mHandler.post(mRunnable);
                    }
                }
            };
        }
        mVideoSurfaceFrame.addOnLayoutChangeListener(mOnLayoutChangeListener);
    }

    @Override
    protected void onStop() {
        super.onStop();
        releaseData();
    }

    private void changeMediaPlayerLayout(int displayW, int displayH) {
        /* Change the video placement using the MediaPlayer API */
        switch (CURRENT_SIZE) {
            case SURFACE_BEST_FIT:
                mMediaPlayer.setAspectRatio(null);
                mMediaPlayer.setScale(0);
                break;
            case SURFACE_FIT_SCREEN:
            case SURFACE_FILL: {
                Media.VideoTrack vtrack = mMediaPlayer.getCurrentVideoTrack();
                if (vtrack == null)
                    return;
                final boolean videoSwapped = vtrack.orientation == Media.VideoTrack.Orientation.LeftBottom
                        || vtrack.orientation == Media.VideoTrack.Orientation.RightTop;
                if (CURRENT_SIZE == SURFACE_FIT_SCREEN) {
                    int videoW = vtrack.width;
                    int videoH = vtrack.height;

                    if (videoSwapped) {
                        int swap = videoW;
                        videoW = videoH;
                        videoH = swap;
                    }
                    if (vtrack.sarNum != vtrack.sarDen)
                        videoW = videoW * vtrack.sarNum / vtrack.sarDen;

                    float ar = videoW / (float) videoH;
                    float dar = displayW / (float) displayH;

                    float scale;
                    if (dar >= ar)
                        scale = displayW / (float) videoW; /* horizontal */
                    else
                        scale = displayH / (float) videoH; /* vertical */
                    mMediaPlayer.setScale(scale);
                    mMediaPlayer.setAspectRatio(null);
                } else {
                    mMediaPlayer.setScale(0);
                    mMediaPlayer.setAspectRatio(!videoSwapped ? "" + displayW + ":" + displayH
                            : "" + displayH + ":" + displayW);
                }
                break;
            }
            case SURFACE_16_9:
                mMediaPlayer.setAspectRatio("16:9");
                mMediaPlayer.setScale(0);
                break;
            case SURFACE_4_3:
                mMediaPlayer.setAspectRatio("4:3");
                mMediaPlayer.setScale(0);
                break;
            case SURFACE_ORIGINAL:
                mMediaPlayer.setAspectRatio(null);
                mMediaPlayer.setScale(1);
                break;
        }
    }

    private void updateVideoSurfaces() {
        int sw = getWindow().getDecorView().getWidth();
        int sh = getWindow().getDecorView().getHeight();
        // sanity check
        if (sw * sh == 0) {
            Log.e(TAG, "Invalid surface size");
            return;
        }
        if (mMediaPlayer != null) {
            mMediaPlayer.getVLCVout().setWindowSize(sw, sh);
        }
        if (mVideoSurface != null) {
            ViewGroup.LayoutParams lp = mVideoSurface.getLayoutParams();
            if (mVideoWidth * mVideoHeight == 0) {
                /* Case of OpenGL vouts: handles the placement of the video using MediaPlayer API */
                lp.width = ViewGroup.LayoutParams.MATCH_PARENT;
                lp.height = ViewGroup.LayoutParams.MATCH_PARENT;
                mVideoSurface.setLayoutParams(lp);
                lp = mVideoSurfaceFrame.getLayoutParams();
                lp.width = ViewGroup.LayoutParams.MATCH_PARENT;
                lp.height = ViewGroup.LayoutParams.MATCH_PARENT;
                mVideoSurfaceFrame.setLayoutParams(lp);
                changeMediaPlayerLayout(sw, sh);
                return;
            }

            if (lp.width == lp.height && lp.width == ViewGroup.LayoutParams.MATCH_PARENT) {
                /* We handle the placement of the video using Android View LayoutParams */
                if (mMediaPlayer != null) {
                    mMediaPlayer.setAspectRatio(null);
                    mMediaPlayer.setScale(0);
                }
            }

            double dw = sw, dh = sh;
            final boolean isPortrait = getResources().getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT;

            if (sw > sh && isPortrait || sw < sh && !isPortrait) {
                dw = sh;
                dh = sw;
            }

            // compute the aspect ratio
            double ar, vw;
            if (mVideoSarDen == mVideoSarNum) {
                /* No indication about the density, assuming 1:1 */
                vw = mVideoVisibleWidth;
                ar = (double) mVideoVisibleWidth / (double) mVideoVisibleHeight;
            } else {
                /* Use the specified aspect ratio */
                vw = mVideoVisibleWidth * (double) mVideoSarNum / mVideoSarDen;
                ar = vw / mVideoVisibleHeight;
            }

            // compute the display aspect ratio
            double dar = dw / dh;

            switch (CURRENT_SIZE) {
                case SURFACE_BEST_FIT:
                    if (dar < ar)
                        dh = dw / ar;
                    else
                        dw = dh * ar;
                    break;
                case SURFACE_FIT_SCREEN:
                    if (dar >= ar)
                        dh = dw / ar; /* horizontal */
                    else
                        dw = dh * ar; /* vertical */
                    break;
                case SURFACE_FILL:
                    break;
                case SURFACE_16_9:
                    ar = 16.0 / 9.0;
                    if (dar < ar)
                        dh = dw / ar;
                    else
                        dw = dh * ar;
                    break;
                case SURFACE_4_3:
                    ar = 4.0 / 3.0;
                    if (dar < ar)
                        dh = dw / ar;
                    else
                        dw = dh * ar;
                    break;
                case SURFACE_ORIGINAL:
                    dh = mVideoVisibleHeight;
                    dw = vw;
                    break;
            }

            // set display size
            lp.width = (int) Math.ceil(dw * mVideoWidth / mVideoVisibleWidth);
            lp.height = (int) Math.ceil(dh * mVideoHeight / mVideoVisibleHeight);
            mVideoSurface.setLayoutParams(lp);
            if (mSubtitlesSurface != null)
                mSubtitlesSurface.setLayoutParams(lp);

            // set frame size (crop if necessary)
            lp = mVideoSurfaceFrame.getLayoutParams();
            lp.width = (int) Math.floor(dw);
            lp.height = (int) Math.floor(dh);
            mVideoSurfaceFrame.setLayoutParams(lp);

            mVideoSurface.invalidate();
            if (mSubtitlesSurface != null)
                mSubtitlesSurface.invalidate();
        }
    }

    @TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR1)
    @Override
    public void onNewVideoLayout(IVLCVout vlcVout, int width, int height, int visibleWidth, int visibleHeight, int sarNum, int sarDen) {
        mVideoWidth = width;
        mVideoHeight = height;
        mVideoVisibleWidth = visibleWidth;
        mVideoVisibleHeight = visibleHeight;
        mVideoSarNum = sarNum;
        mVideoSarDen = sarDen;
        if (isFinishing()){

        } else {
            updateVideoSurfaces();
        }
    }
    }

**demo播放的控制主要是这两个类实现：**

public class PlayerActivity  extends BaseActivity {
    private static final String TAG = "PlayerActivity";
    @ViewInject(R.id.video_play)
    private VideoView mVideoPlay;
    @ViewInject(R.id.progress_loading)
    private ProgressBar mProgresLoading;
    private String mUrl;

    @Override
    public int getLayoutRes() {
        return R.layout.activity_video_player;
    }

    @Override
    public void init() {
        mUrl = getIntent().getStringExtra(ConstData.IntentKey.VIDEO_URL);
        if(TextUtils.isEmpty(mUrl))
            finish();
        mVideoPlay.setOnErrorListener(new MediaPlayer.OnErrorListener() {

            @Override
            public boolean onError(MediaPlayer mp, int what, int extra) {
                Log.i(TAG, "onError");
                mProgresLoading.setVisibility(View.GONE);
                finish();
                return true;
            }
        });
        mVideoPlay.setOnPreparedListener(new MediaPlayer.OnPreparedListener() {

            @Override
            public void onPrepared(MediaPlayer mp) {
                Log.i(TAG, "onPrepared");
                mProgresLoading.setVisibility(View.GONE);
            }
        });
    }



    @Override
    protected void onResume() {
        super.onResume();
        playVideo();
    }

    @Override
    protected void onPause() {
        super.onPause();
        mVideoPlay.pause();

    }

    @Override
    protected void onStop() {
        super.onStop();
        try{
            mVideoPlay.stopPlayback();
        }catch (Exception e){

        }

    }

    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        if(keyCode == KeyEvent.KEYCODE_BACK){
            mProgresLoading.setVisibility(View.GONE);
            finish();
            return true;
        }
        return super.onKeyDown(keyCode, event);
    }

    private void playVideo(){
        try{
            mVideoPlay.stopPlayback();
        }catch (Exception e){

        }
        mProgresLoading.setVisibility(View.VISIBLE);
        mVideoPlay.setVideoURI(Uri.parse(mUrl));
        mVideoPlay.start();
    }

在这里插入图片描述
可以自己把jni部分源码复写，播放主要控制在libvlc

在这里插入图片描述
在这里插入图片描述

四、前期工作做完后，我们可以先来简要了解vlc的播放器工作；音视频的播放我们一般有几个步骤，主要是：

步骤工作内容简要说明
1access访问接收、获取、得到数据资源，包括解析访问源（url）, 使用http协议，rtsp协议，ftp协议，建立连接，获取数据
2demux解复杂音频和视频分离，当然也有可能有字幕。通过分析数据包头来判断是什么数据文件，需要用什么解码格式
3decode解码包括音频和视频解码，或者软件解码和硬件解码。
4output输出分为音频和视频的输出（aout和vout）
VLC源码结构对应功能
./config/从命令行和配置文件中加载配置
./control/提供动作控制功能,如播放等操作
./extras/大多是平台的特殊代码
./modules/模块管理
./network/提供网络接口(socket管理,网络接口)
./osd/显示屏幕上的操作
./test/libvlc测试模块
./text/字符集
./interface/提供代码中可以调用的接口,如按键后的硬件作出反应
./playlist/管理播放功能
./input/建立并读取一个输入流,并且分离其中的音频和视频,然后把分离好的音频和视频流发给解码器
./audio_output/初始化音频混合器,即设置正确的同步频率,并对从解码器传来的音频流重新取样
./video_output/初始化视频播放器,把从解码器得到视频画面转化格式从yuv到rgb,然后播放
./stream_output/ /输出音频流和视频流到网络
./misc/libvlc使用的其他部分功能,如线程系统,消息队列等
  • VLC
    采用全模块化结构，通过动态的载入所需的模块，放入一个module_bank的结构体中统一管理，连VLC的Main模块也是通过插件的方式动态载入的（通过module_InitBank函数在初始化建立module_bank时）。对于不支持动态载入插件的系统环境中，VLC也可以采用builtin的方式，在VLC启动的时候静态载入所需要的插件，并放入module_bank统一管理。

五、附上自己编译的源码Vlc生成的apk以及demo生成的apk；

链接: https://pan.baidu.com/s/1YnPus6koPLI4-LEUzPADlA
提取码: w7ya

Mr.Grapes
关注
专栏目录
如何在Android项目中使用VLC
3年2班的博客
04-20 3940
先说一下为什么要使用VLC,因为项目中要求播放流媒体，以前并没有接触过这块。 常用Android视频播放技术： android SDK: MediaPlayer + SurfaceView android SDK: VideoView Google开源库：Exoplayer Vitamio VLC FFmpeg 其它开源播放器，如ijkplayer FFmpeg FFmpe...
android 集成VLC 流媒体视频播放Demo
12-27
简单的集成vlc，也方便各位学习和移植源码，过多的东西不用介绍，看其中的源码就行。提醒：移植过程中切要保持vlc源码包名不变，例如对于视频的控制，相信大家都能自己扩展实现。
android vlc sdk
最新发布
weixin_35929851的博客
07-30 63
ide相关学习资料：https://edu.51cto.com/video/3502.htmlAndroid VLC SDK 科普 VLC 是一款开源的多媒体播放器，支持多种音频和视频格式。它不仅可以在桌面上使用，还可以在 Android 平台上运行。VLC SDK 是 VideoLAN 组织为 Android 开发者提...
Android VLC音频视频播发器快速集成教程与模块
楠之枫雪的博客
11-23 6795
通过该文，你能很简单的知道怎么使用vlc，并且通过封装好的方法，很简单的几句代码就能实现音频视频本地与在线播放。并能实现android vlc功能的快速集成。
libvlc-3.3 for android, 用于android 集成vlc 播放器内核的库
07-18
7月15 日从官方拉出 最新的 vlc-android 源码编译而成，libvlc 为最新3.3 版本。支持armv7a/armv8/x86.平台。可用于开发android 播放器。
VLC架构剖析
zjf82031913的专栏
08-23 8143
VLC架构剖析 1. VideoLan简介 1.1 videolan组成 Videolan有以下两部分组成: VLC:一个最主要的部分，它可以播放各种类型的媒体文件和流媒体文件，并且可以创造媒体流并保存成各种格式的媒体文件，这些文件的质量要比没保存前的件好。videolan作为客户端可以播放本地文件，httP://，rtsp://。 VLS:是一种流服务器，专门用来解决流的各种问题，它也
可用于Android集成VLC播放器的libvlc-3.0.0.aar库,支持H264格式等多路实时流播放（如rtsp,rtmp,http）
06-19
可用于Android集成VLC播放器的库。支持h264,mp4,flv,avi,rmvb等等等多种格式，亲测可用。支持多路实时流播放（如rtsp,rtmp,http）
vlc-android-1.9.0_vlc_github_android开发_doublex4o_player_
09-29
VLC是一款广受欢迎的开源媒体播放器，它支持多种视频和音频格式，具有跨平台的特点。在Android平台上，VLC...如果要深入了解或参与VLC的Android开发，可以从这些文件入手，学习其架构设计、编码规范以及如何扩展功能。
android实现vlc播放本地视频
02-27
**集成VLC库** 1. 将`libvlc-x86-3.1.0.aar`文件添加到你的Android项目的`libs`目录下。 2. 更新你的`build.gradle`文件，将aar文件作为库引用。添加以下代码到`dependencies`部分： ``` implementation(name: '...
vlc android demo
05-31
在Android Studio中编译VLC源码，开发者需要具备一定的Android开发知识，包括对Gradle构建系统的理解，以及可能需要的NDK（Native Development Kit）知识，因为VLC涉及到C/C++的原生库。步骤通常包括以下几个部分： ...
LibVlc:Android VLC 库 (armeabi-v7a)。 AAR包
06-26
LibVlc是针对Android平台的VLC库，主要为开发者提供了在Android应用中集成VLC媒体播放功能的能力。这个库是专门为armeabi-v7a架构优化的，这意味着它支持ARMv7指令集，广泛应用于大多数现代Android设备。AAR...
android vlc
02-25
android vlc精简demo，用来渲染流媒体
vlc-android
07-24
Android版的vlc播放器，已编译，有两个工程，导入后，清理下工程，可正常，编译时采用armeabi-v7a和NO_NEON=1,两个参数。可在模拟器中运行
vlc for android
09-07
编译的libvlc，支持摄像头的rtsp流 下载后作为Module引用.在gradle里面的defaultConfig加上ndk {abiFilters 'armeabi-v7a'} 不然其他平台会出问题
vlc-android播放rtsp视频流demo
11-18
android集成VLC播放rtsp视频流，很好用，直接传rtsp就可以播放，我也是在网上看到的（之前上传的不知道为什么源码变了，重新上传一次）
vlc集成，rtsp流播放
09-06
1.vlc 1.0集成， 安卓6.07 7.0 rtsp流播放不黑屏 github大部分demo 安卓6.0以上手机只有音频 视频黑屏 2.这个demo亲测可用 3. 此demo安卓sdk最高支持22 ，不然安卓7.0会报错。
VLC Android 3.0.0编译 aar
08-07
对于需要在Android应用中集成VLC播放器功能的开发者来说，这个编译好的aar文件集合是一个宝贵的资源，可以快速地将VLC的功能整合到自己的应用中，而无需从源码开始编译整个项目。 总的来说，VLC Android 3.0.0编译...
VLC架构及流程分析
热门推荐
hpb21的专栏
01-29 1万+
0x00 前置信息 VLC是一个非常庞大的工程，我从它的架构及流程入手进行分析，涉及到一些很细的概念先搁置一边，日后详细分析。 0x01 源码结构（Android Java相关的暂未分析） # build-android-arm-linux-androideabi/：第三方库。 # modules/：模块代码。 # modules/demux: 解复用模块代码。 # mod
android电视直播集成,vlc_for_android(基于git-3.0.0)快速集成并播放电视节目直播
weixin_33147645的博客
05-26 866
VLC是用的很广泛的多媒体播放器框架，我之前也写过关于《VLC源码及各modules功能介绍》，VLC较其他多媒体播放框架要复杂更多。今天是djstava关于他编译vlc-android源码移植，并播放电视节目直播案例。说实话，很多人连vlc-android编译出库文件出来都要折腾好久。这篇文章对你绝对有借鉴意义。前言最近老有朋友在问vlcforandroid的移植问题，网络上有一些帖子也有谈到，...
android 集成vlc 代码示例
04-24
很高兴能够回答您的问题。以下是一个简单的示例代码，可以用于在 Android 中集成 VLC 播放器： 1. 在您的项目中添加以下依赖项： ``` implementation "de.mrmaffen:vlc-android-sdk:3.2.0@aar" ``` 2. 在您的布局文件中添加一个 SurfaceView： ``` <SurfaceView android:id="@+id/surfaceView" android:layout_width="match_parent" android:layout_height="match_parent" /> ``` 3. 在您的 Activity 中初始化 VLC： ``` import android.net.Uri; import android.os.Bundle; import android.view.SurfaceHolder; import android.view.SurfaceView; import androidx.appcompat.app.AppCompatActivity; import org.videolan.libvlc.LibVLC; import org.videolan.libvlc.Media; import org.videolan.libvlc.MediaPlayer; import java.util.ArrayList; public class MainActivity extends AppCompatActivity implements SurfaceHolder.Callback { private SurfaceView surfaceView; private LibVLC libVLC; private MediaPlayer mediaPlayer; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); surfaceView = findViewById(R.id.surfaceView); surfaceView.getHolder().addCallback(this); libVLC = new LibVLC(this); mediaPlayer = new MediaPlayer(libVLC); } @Override public void surfaceCreated(SurfaceHolder holder) { mediaPlayer.getVLCVout().setVideoSurface(holder.getSurface(), holder); mediaPlayer.getVLCVout().attachViews(); Media media = new Media(libVLC, Uri.parse("http://example.com/video.mp4")); mediaPlayer.setMedia(media); mediaPlayer.play(); } @Override public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) { } @Override public void surfaceDestroyed(SurfaceHolder holder) { mediaPlayer.stop(); mediaPlayer.getVLCVout().detachViews(); } @Override protected void onDestroy() { mediaPlayer.release(); libVLC.release(); super.onDestroy(); } } ``` 请注意，上述示例中的视频 URL 仅用作示例。您应该在 `Uri.parse()` 中使用实际的视频 URL。同时，这只是一个简单的示例，您可能需要对代码进行修改，以满足您的特定需求。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值