你的打赏，是对我最大的支持：



 

测试地址：rtsp://218.204.223.237:554/live/1/0547424F573B085C/gsfp90ef4k0a6iap.sdp

本demo测试地址：rtsp://admin:a88888888@183.230.153.189:554

 

测试方法：

 

在PC端下载 VLC 播放器 

下载地址：

https://vlc-media-player.en.softonic.com/



 

demo运行结果



 

补充一句：不足的地方 就是第一次打开有点慢，30s

 

废话不多说了，上代码

 

 

主要代码：

package demo.one;

//.....
/**
 * _ooOoo_
 * o8888888o
 * 88" . "88
 * (| -_- |)
 * O\ = /O
 * ____/`---'\____
 * . ' \\| |// `.
 * / \\||| : |||// \
 * / _||||| -:- |||||- \
 * | | \\\ - /// | |
 * | \_| ''\---/'' | |
 * \ .-\__ `-` ___/-. /
 * ___`. .' /--.--\ `. . __
 * ."" '< `.___\_<|>_/___.' >'"".
 * | | : `- \`.;`\ _ /`;.`/ - ` : | |
 * \ \ `-. \_ __\ /__ _/ .-` / /
 * ======`-.____`-.___\_____/___.-`____.-'======
 * `=---='
 * <p>
 * .............................................
 * 佛祖保佑 永无BUG
 *
 * @ProjectName: Demo_one
 * @Package: demo.one
 * @ClassName: VideoPalyerActivity
 * @Description: java类作用描述,播放RSTSP视频 播放地址：拼接方式 
 *
 *  rtsp://123:123456@183.230.153.189:554
 *
 *  123   账户
 *  123456  密码
 *  中间用冒号隔开：小写
 *
 * 183.230.153.189:554   播放地址 + 端口
 *
 *用@符号
 *
 * @Author: HCJ
 * @CreateDate: 2019/8/26 17:38
 * @UpdateUser: 更新者
 * @UpdateDate: 2019/8/26 17:38
 * @UpdateRemark: 更新说明
 * @Version: 1.0
 */
public class VideoPalyerActivity extends AppCompatActivity implements IVLCVout.OnNewVideoLayoutListener {

    private static final String TAG = "VideoPalyerActivity";

    private static final boolean ENABLE_SUBTITLES = true;
    private static String SAMPLE_URL = "rtsp://admin:a88888888@183.230.153.189:554";
    //    private static String SAMPLE_URL;
    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;

    //    private void init() {
//        Configuration mConfiguration = this.getResources().getConfiguration(); //获取设置的配置信息
//        int ori = mConfiguration.orientation; //获取屏幕方向
//
//        if (ori == mConfiguration.ORIENTATION_PORTRAIT) {
//            //竖屏
//            setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);//强制为横屏
//        }
//
//
//    }

    private void changeMediaPlayerLayout(int displayW, int displayH) {
        /* Change the video placement using the MediaPlayer API */
        switch (CURRENT_SIZE) {
            case SURFACE_BEST_FIT:
                mMediaPlayer.setAspectRatio("3:2");
                mMediaPlayer.setScale(0);
                break;
            case SURFACE_FIT_SCREEN:
                break;
            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;
        }

        mMediaPlayer.getVLCVout().setWindowSize(sw, sh);

        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 */
            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;
        updateVideoSurfaces();
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_videoplayer);
//        SAMPLE_URL = getIntent().getStringExtra("extra_url");
//        Log.d(TAG, "onCreate: " + SAMPLE_URL);

//        init();
        ArrayList<String> args = new ArrayList<>();
        args.add("-vvv");
        mLibVLC = new LibVLC(getApplicationContext(), args);
        mMediaPlayer = new MediaPlayer(mLibVLC);
        mMediaPlayer.setScale(0);

        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 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("rtsp://admin:a88888888@183.230.153.189:554"));
        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();

        if (mOnLayoutChangeListener != null) {
            mVideoSurfaceFrame.removeOnLayoutChangeListener(mOnLayoutChangeListener);
            mOnLayoutChangeListener = null;
        }

        mMediaPlayer.stop();

        mMediaPlayer.getVLCVout().detachViews();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        mMediaPlayer.release();
        mLibVLC.release();
    }
}



 

布局：

activity_videoplayer:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:orientation="vertical">


    <FrameLayout
        android:id="@+id/video_surface_frame"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:foregroundGravity="clip_horizontal|clip_vertical"
        android:gravity="center"
        tools:ignore="true">

        <SurfaceView
            android:id="@+id/video_surface"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:gravity="center" />

        <ViewStub
            android:id="@+id/subtitles_stub"
            android:layout_width="1dp"
            android:layout_height="1dp"
            android:layout="@layout/subtitles_surface" />


    </FrameLayout>

</LinearLayout>


 

subtitles_stub:
<?xml version="1.0" encoding="utf-8"?>
<SurfaceView xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="1dp"
    android:layout_height="1dp">
</SurfaceView>

 

 

引用包：

implementation files('libs/****.jar')


        ndk {
            //选择要添加的对应cpu类型的.so库。
            abiFilters 'armeabi', 'armeabi-v7a'//, 'arm64-v8a', 'x86', 'x86_64'
            // 还可以添加 'x86', 'x86_64', 'mips', 'mips64'
        }

 

build 

apply plugin: 'com.android.application'

android {
    compileSdkVersion 28
    defaultConfig {
        applicationId "demo.one"
        minSdkVersion 15
        targetSdkVersion 28
        versionCode 1
        versionName "1.0"
        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"

        ndk {
            //选择要添加的对应cpu类型的.so库。
            abiFilters 'armeabi', 'armeabi-v7a'//, 'arm64-v8a', 'x86', 'x86_64'
            // 还可以添加 'x86', 'x86_64', 'mips', 'mips64'
        }

    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    implementation 'com.android.support:appcompat-v7:28.0.0'
    implementation 'com.android.support.constraint:constraint-layout:1.1.3'
    implementation 'com.android.support:design:28.0.0'
    testImplementation 'junit:junit:4.12'
    androidTestImplementation 'com.android.support.test:runner:1.0.2'
    androidTestImplementation 'com.android.support.test.espresso:espresso-core:3.0.2'


    implementation files('libs/****.jar')
}


 

权限：

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    package="demo.one">

   //......

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">
        <activity
            android:name=".VideoPalyerActivity"
            android:label="@string/app_name"
            android:theme="@style/AppTheme.NoActionBar">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>

AndroidManifest.xml 全部贴上来 给你们 看



在src/main 加上 jniLibs 库



 

$99 for source code configuration：



 

1 connect usb camera to linux system

2 ls /dev/video*

3 in server side: cvlc v4l2:///dev/video4 --sout '#transcode{vcodec=mjpg}:std{access=http,mux=mpjpeg,dst=127.0.0.1:13000}'

4 in client side: vlc http://127.0.0.1:13000

 

list camera devices

v4l2-ctl --list-devices

 

list format of camera

ffmpeg -f v4l2 -list_formats all -i /dev/video0

 

 

 

redirect usb camera from thin client to guest os

1. in guest os

insmod v4l2loopback.ko

assume v4l2loopback create /dev/video6 as a capture device.

2 in thin client

cvlc v4l2:///dev/video4 --sout '#transcode{vcodec=h264,vb=800,acodec=mp4a}:rtp{sdp=rtsp://127.0.0.1:13000/live.ts}'

assume usb camera capture device is /dev/video4

3 in guest os

ffmpeg -i rtsp://127.0.0.1:13000/live.ts -f v4l2  /dev/video6

guest os receive the data from thin client, send it to loopback device /dev/video6

4 in guest

vlc v4l2:///dev/video6

using vlc show the contents of /dev/video6

 在做视频传输客户端开发的时候，经常需要用到流媒体服务，VLC有着非常强大的流媒体处理能力，同时它也可以搭建流媒体服务器。VLC是一种开源的播放器，同时也可以用作流媒体服务器。
vlc搭建rtsp流媒体服务器步骤：
1、打开vlc，选择流
媒体-流
2、选择文件选项卡，添加一个视频文件，基本vlc可以播放的都能添加。
3、选择流输出参数。
这里要选择rtsp，然后点击 添加 按钮。
端口需要主要不能冲突，一般默认的8554即可，路径根据需要设置或不设置。
可以选择激活转码然后系统会转码后再转发流出去，如果电脑配置不够会很卡延时等等问题的。不选择的话根据视频原本编码方式发出去。
sdp地址默认ip不填，默认是本地电脑ip地址。rtsp://:8554/test实际上等价于rtsp://本地ip:8664/test 比如：rtsp://192.168.1.198:8554/test
sdp这里不用填ip，除非是多网卡。
点击流即可。
4、如果文件播放完了，rtsp服务会自动关闭，我们选择一个循环图标，会一直提供rtsp服务，便于测试。如下图：
vlc播放视频rtsp流测试：
1、telnet上面的sdp中端口，看是否连接上，如果无法连接上，说明配置参数不对或视频源非标准视频导致rtsp服务搭建失败了。
telnet 
telnet成功，说明连接是通的
2、再打开一个VLC，打开网络播放，添加上一步我们设置的SDP 路径rtsp://192.168.1.198:8554/test
3、点击play,实现流媒体的播放，正常情况下会显示视频画面。

最新项目涉及到摄像头，这篇文章记录一下在VUE中播放RTSP视频流。
这篇文章主要介绍使用VLC插件播放RTSP视频流，目前支持的浏览器有 360浏览器、2345浏览器，可用于一些对播放器要求不高的项目中。
安装VL插件
VLC插件网上有很多，需要的小伙伴网上下载一个就行，我用的是 vlc-3.0.8-win32.exe ，我有使用过 win64 的发现插件不支持，具体原因还没有去深究，知道的小伙伴欢迎留言。
安装VLC主要注意勾选 Mozilla 插件，否则视频流也是播放不了的。
播放RTSP视频流
rtsp视频流播放是使用 标签
width="100%"  height="100%">
使用此方法会产生一个很难受的问题，就是  会默认是最顶层的，并且z-index 也控制不了他的层级。
因为 标签不在 dom 文档流里面，浏览器在解析的时候先把 放置在最上层，然后依次解析dom文档，放在下层，所以在这里使用z-index是无效的。
为了解决这个问题，我引入了 标签， 标签的级别高于  标签，而又由于
能够遮挡，所以可以通过在
中加入来解决该类问题。
这样处理虽然不是最好的方法，但是勉强能实现视频播放。
还有更好的办法欢迎留言！