Android接受RTP传输的Camera数据

已于 2022-02-28 17:56:16 修改
阅读量1.6k 收藏 7
点赞数 4
分类专栏： Android Camera RTP 文章标签： android rtp
于 2020-02-26 14:29:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zgz9949/article/details/104516353
版权

上一篇说了如何发送的，那么这边就看下接收端的代码。
接受端主要是接受到数据后，解码，然后在SufaceView上预览。
这个比较简单，我就直接贴代码了。

如下代码源码地址

主要参考了这篇博客：android硬编码h264数据，并使用rtp推送数据流，实现一个简单的直播-MediaCodec（二）

public class ClientTextureView extends TextureView implements  TextureView.SurfaceTextureListener{
    private static  final String MIME_TYPE = "video/avc";
    private static final String TAG = "ClientTextureView" ;
    private static final int PORT = 5004;
    private DatagramSocket mSocket;
    private MediaCodec mDecode;
    private byte[] mRtpData =  new byte[80000];
    private byte[] mH264Data = new byte[80000];

    public ClientTextureView(Context context, AttributeSet attrs) {
        super(context, attrs);
        setSurfaceTextureListener(this);
        try {
            mSocket = new DatagramSocket(PORT);
            mSocket.setReuseAddress(true);
            mSocket.setBroadcast(true);
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }

    @RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN)
    @Override
    public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) {
        Log.i(TAG, "SurfaceTexture width " + width + "; height" + height);
        new PreviewThread(new Surface(surface), width, height);
    }

    @Override
    public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
        if (mSocket != null){
            mSocket.close();
            mSocket = null;
        }
        return false;
    }
    @Override
    public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) { }
    @Override
    public void onSurfaceTextureUpdated(SurfaceTexture surface) { }

    private  class  PreviewThread extends  Thread {
        DatagramPacket datagramPacket = null;
        @RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN)
        public PreviewThread(Surface surface, int width , int height){
            Log.i(TAG, "PreviewThread surface width " + width + "; height" + height);
            try {
                mDecode = MediaCodec.createDecoderByType(MIME_TYPE);
                final MediaFormat format = MediaFormat.createVideoFormat(MIME_TYPE, width, height);
                format.setInteger(MediaFormat.KEY_BIT_RATE, 40000);
                format.setInteger(MediaFormat.KEY_FRAME_RATE, 30);
                format.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, 1);
                byte[] header_sps = {0, 0, 0, 1, 103, 66, 0 , 41, -115, -115, 64, 80 , 30 , -48 , 15 ,8,-124, 83, -128};
                byte[] header_pps = {0, 0, 0, 1, 104, -54, 67, -56};
                format.setByteBuffer("csd-0", ByteBuffer.wrap(header_sps));
                format.setByteBuffer("csd-1", ByteBuffer.wrap(header_pps));

                mDecode.configure(format, surface, null, 0);
                mDecode.start();
            } catch (IOException e) {
                e.printStackTrace();
            }
            start();
        }

        @RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN)
        @Override
        public void run() {
            byte[] data = new byte[80000];
            int h264Length = 0;
            while (true){
                if (mSocket != null){
                    try {
                        datagramPacket = new DatagramPacket(data, data.length);
                        mSocket.receive(datagramPacket);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                mRtpData = datagramPacket.getData();
                if (mRtpData != null ){
                    if (mRtpData[0] == -128 && mRtpData[1] == 96){
                        int l1 = (mRtpData[12] << 24) & 0xff000000;
                        int l2 = (mRtpData[13] << 16) & 0x00ff0000;
                        int l3 = (mRtpData[14] << 8) & 0x0000ff00;
                        int l4 = mRtpData[15] & 0x000000FF;
                        h264Length = l1 + l2 + l3 + l4;
                        Log.i(TAG, "run: h264Length="+h264Length);
                        System.arraycopy(mRtpData,16, mH264Data,0,h264Length);
                        Log.i(TAG, "run:h264Data[0]="+mH264Data[0]+","+mH264Data[1]+","+mH264Data[2]+","+mH264Data[3]
                                +","+mH264Data[4]+","+mH264Data[5]+","+mH264Data[6]+","+mH264Data[7]
                                +","+mH264Data[8]+","+mH264Data[9]+","+mH264Data[10]
                                +","+mH264Data[11]+","+mH264Data[12]+","+mH264Data[13]
                                +","+mH264Data[14]+","+mH264Data[15]+","+mH264Data[16]
                                +","+mH264Data[17]+","+mH264Data[18]+","+mH264Data[19]
                                +","+mH264Data[20]+","+mH264Data[21]+","+mH264Data[22]);
                        offerDecoder(mH264Data,mH264Data.length);
                    }
                }
            }
        }
    }

    @RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN)
    private void offerDecoder(byte[] input, int length) {
         Log.d(TAG, "offerDecoder: ");
        try {
            ByteBuffer[] inputBuffers = mDecode.getInputBuffers();
            int inputBufferIndex = mDecode.dequeueInputBuffer(0);
            if (inputBufferIndex >= 0) {
                ByteBuffer inputBuffer = inputBuffers[inputBufferIndex];
                inputBuffer.clear();
                try{
                    inputBuffer.put(input, 0, length);
                }catch (Exception e){
                    e.printStackTrace();
                }
                mDecode.queueInputBuffer(inputBufferIndex, 0, length, 0, 0);
            }
            MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();

            int outputBufferIndex = mDecode.dequeueOutputBuffer(bufferInfo, 0);
            while (outputBufferIndex >= 0) {
                //If a valid surface was specified when configuring the codec,
                //passing true renders this output buffer to the surface.
                mDecode.releaseOutputBuffer(outputBufferIndex, true);
                outputBufferIndex = mDecode.dequeueOutputBuffer(bufferInfo, 0);
            }
        } catch (Throwable t) {
            t.printStackTrace();
        }
    }
}

MainActivity

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
    }
}

AndroidManifest

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

    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
    <uses-permission android:name="android.permission.INTERNET"/>
    <uses-permission android:name="android.permission.RECORD_VIDEO"/>
    <uses-permission android:name="android.permission.RECORD_AUDIO"/>
    <uses-permission android:name="android.permission.CAMERA" />
    <uses-feature android:name="android.hardware.camera" />
    <uses-feature android:name="android.hardware.camera.autofocus" />
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
    <uses-feature android:name="android.hardware.wifi" android:required="true" />

    <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=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

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

</manifest>

这篇的代码跟参考的差不多，我就不上传到GitHub了，大家可以参考上面的那片。如需要上传的话，欢迎留言。

在上一篇说了要分包发送，那么在这里就要有对应的协议解包。代码如下：

package com.byd.rtpclientdemo;

import android.content.Context;
import android.graphics.SurfaceTexture;
import android.media.MediaCodec;
import android.media.MediaFormat;
import android.os.Build;
import android.util.AttributeSet;
import android.util.Log;
import android.view.Surface;
import android.view.TextureView;

import androidx.annotation.RequiresApi;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
import java.nio.ByteBuffer;

public class ClientTextureView extends TextureView implements TextureView.SurfaceTextureListener {
    private static final String MIME_TYPE = "video/avc";
    private static final String TAG = "ClientTextureView";
    private byte[] mH264Data = new byte[200000];
    private static final int PORT = 5004;
    private int mHeight = 1080;
    private int mWidth = 1920;
    private DatagramSocket mSocket;
    private MediaCodec mDecode;

    public ClientTextureView(Context context, AttributeSet attrs) {
        super(context, attrs);
        setSurfaceTextureListener(this);
        try {
            mSocket = new DatagramSocket(PORT);
            mSocket.setReuseAddress(true);
            mSocket.setBroadcast(true);
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }

    @RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN)
    @Override
    public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) {
        new PreviewThread(new Surface(surface));
    }

    @Override
    public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
        if (mSocket != null) {
            mSocket.close();
            mSocket = null;
        }
        return false;
    }

    @Override
    public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) {
    }

    @Override
    public void onSurfaceTextureUpdated(SurfaceTexture surface) {
    }

    private class PreviewThread extends Thread {
        DatagramPacket datagramPacket = null;

        @RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN)
        public PreviewThread(Surface surface) {
            try {
                mDecode = MediaCodec.createDecoderByType(MIME_TYPE);
                final MediaFormat format = MediaFormat.createVideoFormat(MIME_TYPE, mWidth, mHeight);
                format.setInteger(MediaFormat.KEY_FRAME_RATE, 15);
                format.setInteger(MediaFormat.KEY_BIT_RATE, 1900000);
                format.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, 1);
                byte[] header_sps = {0, 0, 0, 1, 103, 66, 0, 41, -115, -115, 64, 80, 30, -48, 15, 8, -124, 83, -128};
                byte[] header_pps = {0, 0, 0, 1, 104, -54, 67, -56};
                format.setByteBuffer("csd-0", ByteBuffer.wrap(header_sps));
                format.setByteBuffer("csd-1", ByteBuffer.wrap(header_pps));

                mDecode.configure(format, surface, null, 0);
                mDecode.start();
            } catch (IOException e) {
                e.printStackTrace();
            }
            start();
        }

        @RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN)
        @Override
        public void run() {
            boolean isFiset = true;
            int pre_seq_num = 0;
            int destPos = 0;
            int h264Length;
			
			//下面便是解协议的操作，对应的是发送方分包发送。
            while (true) {
                if (mSocket != null) {
                    try {
                        byte[] data = new byte[1500];
                        datagramPacket = new DatagramPacket(data, data.length);
                        mSocket.receive(datagramPacket);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                //接受到的一次数据
                byte[] rtpData = datagramPacket.getData();
                if (rtpData != null) {
                	//取出每次发送的数据的大小
                    int l3 = (rtpData[12] << 24) & 0xff000000;
                    int l4 = (rtpData[13] << 16) & 0x00ff0000;
                    int l5 = (rtpData[14] << 8) & 0x0000ff00;
                    int l6 = rtpData[15] & 0x000000FF;
                    h264Length = l3 + l4 + l5 + l6;
                    Log.i(TAG, "run: h264Length = " + h264Length);
					
					//获取序列号
                    byte[] snm = new byte[2];
                    System.arraycopy(rtpData, 2, snm, 0, 2);
                    int seq_num = CalculateUtil.byte2short(snm);
                    Log.i(TAG, "seq_num = " + seq_num);
					
					//获取时间戳
                    int timeStamp1 = (rtpData[4] << 24) & 0xff000000;
                    int timeStamp2 = (rtpData[5] << 16) & 0x00ff0000;
                    int timeStamp3 = (rtpData[6] << 8) & 0x0000ff00;
                    int timeStamp4 = rtpData[7] & 0x000000FF;
                    int timeStamp = timeStamp1 + timeStamp2 + timeStamp3 + timeStamp4;
                    Log.i(TAG, "timeStamp = " + timeStamp);
					
					//这个地方是我之前调试用的，就是看看丢包率是多少。
                    if (isFiset) {
                        pre_seq_num = seq_num;
                        isFiset = false;
                    } else {
                        if (seq_num - pre_seq_num > 1) {
                            Log.i(TAG, "Packet loss" + (seq_num - pre_seq_num));
                        } else if (seq_num - pre_seq_num < 1) {
                            Log.i(TAG, "Out of order packets" + (seq_num - pre_seq_num));
                        }
                        pre_seq_num = seq_num;
                    }
					
					//此值代表是否分包。
                    byte indicatorType = (byte) (CalculateUtil.byteToInt(rtpData[16]) & 0x1f);
                    Log.i(TAG, "indicatorType = " + indicatorType);
                    //分包
                    if (indicatorType == 28) {
                        byte s = (byte) (rtpData[17] & 0x80);
                        byte e = (byte) (rtpData[17] & 0x40);
                        Log.i(TAG, "s = " + s + "; e = " + e);
						
                        if (s == -128) {        // 一帧的第一包
                            System.arraycopy(rtpData, 18, mH264Data, destPos, h264Length);
                            destPos += h264Length;
                        } else if (e == 64) {   // 一帧的最后一包
                            System.arraycopy(rtpData, 18, mH264Data, destPos, h264Length);
                            destPos = 0;
                            offerDecoder(mH264Data, mH264Data.length);
                            CalculateUtil.memset(mH264Data, 0, mH264Data.length);
                        } else {	//一帧的中间的包
                            System.arraycopy(rtpData, 18, mH264Data, destPos, h264Length);
                            destPos += h264Length;
                        }
                    } else {	//不分包
                        System.arraycopy(rtpData, 16, mH264Data, 0, h264Length);
                        offerDecoder(mH264Data, mH264Data.length);
                        CalculateUtil.memset(mH264Data, 0, mH264Data.length);
                    }

                }
            }
        }
    }

    @RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN)
    private void offerDecoder(byte[] input, int length) {
        Log.d(TAG, "offerDecoder");
        try {
            ByteBuffer[] inputBuffers = mDecode.getInputBuffers();
            int inputBufferIndex = mDecode.dequeueInputBuffer(0);
            if (inputBufferIndex >= 0) {
                ByteBuffer inputBuffer = inputBuffers[inputBufferIndex];
                inputBuffer.clear();
                try {
                    inputBuffer.put(input, 0, length);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                mDecode.queueInputBuffer(inputBufferIndex, 0, length, 0, 0);
            }
            MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();

            int outputBufferIndex = mDecode.dequeueOutputBuffer(bufferInfo, 0);
            while (outputBufferIndex >= 0) {
                //If a valid surface was specified when configuring the codec,
                //passing true renders this output buffer to the surface.
                mDecode.releaseOutputBuffer(outputBufferIndex, true);
                outputBufferIndex = mDecode.dequeueOutputBuffer(bufferInfo, 0);
            }
        } catch (Throwable t) {
            t.printStackTrace();
        }
    }
}
将来路远111
关注
专栏目录
Android调用Jlibrtp实现RTP发送数据Demo
10-27
Android调用Jlibrtp库实现RTP发送数据Demo，建立收发端会话，配置RTP/RTCP端口号，添加参与者等；请参考我的博客：http://blog.csdn.net/ericfantastic/article/details/49361069
android studio 通过 rtp 发送和接收demo
04-17
android studio 通过 rtp 发送和接收demo 主要是将官网中的jlibrtp 0.2.2协议包含的例子引用到工程中 demo中采用局域网广播的形式来发送数据 指定的ip需要自己去尝试
Android轻量级RTSP服务使用场景分析和设计探讨
最新发布
乐学吧
09-19 2209
实现一个完整的轻量级RTSP服务是一个相对复杂的任务，需要对音视频处理、网络编程和RTSP协议有深入的理解。好多开发者，对我们Android平台轻量级RTSP服务模块有些陌生，不知道这个模块具体适用于怎样的场景，有什么优缺点，实际上，我们的Android平台轻量级RTSP服务模块更适用于内网环境下、对并发要求不高的场景，实现低成本、低延迟的音视频实时传输。：在这些环境中，需要实现音视频的低延迟传输，而轻量级RTSP服务能够避免单独部署RTSP或RTMP服务器，简化部署流程，同时满足对并发要求不高的场景。
android使用RTP传输Camera数据
zgz9949的博客
02-26 3357
最近公司要做一个一对一的视频传输的项目，要求使用Camera2API传输H264格式的数据。我们这篇文章主要是说怎么实现的，原理部分我会附上其他链接。 那么来看下发送端的主要逻辑。 1.获取Camera数据 2.将获取到的Camera数据转换成YUV420SP格式 3.使用MediaCodec硬编码成H264数据 4.使用RTP协议跟Socket发送Camera数据 1.获取Camera数据 原...
android player通过rtp协议接收h264视频数据播放
chuyouyinghe的专栏
06-06 700
一、接收数据rtp包的组包与拆包已经由rtp 库完成，这里可以从rtp库的回调直接接收到原始发送的数据。我们可以看到rtp payload指定的类型是96，96代表的就是h264视频数据类型。这里监听的是偶数端口40018，奇数端口留给rtcp使用。我们接收到的数据是nalu分片数据，我们还需要把分片数据组成完整的nalu数据。
Android使用rtp传输的Jlibrtp库
09-04
在使用RTP/RTCP协议发送数据是有现成的库进行调用的，Jlibrtp这个库就是Java实现的， 下完后，新建一个Android工程，将Jlibrtp-0.2.2中的jlibrtp文件夹中的所有.java文件导入工程，全丢到一个新建的jlibrtp包里面，准备工作算是完成，在需要地方直接import这个包，就可以使用了。
Android RTP/RTCP
04-27
Android RTP/RTCP
Rtp协议传输Camera视频流
04-18
在本文中，我们将深入探讨如何使用RTP（Real-time Transport Protocol）协议来传输Camera视频流。首先，让我们从基础开始，了解RTP、NV21、NV12、MediaCodec以及SurfaceView等关键概念。 RTP协议是互联网工程任务组...
android用live555 rtsp服务器传输camera图像示例代码
05-08
6. 从Android的`Camera`或`Camera2` API获取摄像头数据，使用`MediaCodec`进行编码。 7. 将编码后的数据通过`RTPSink`发送到RTSP服务器，供客户端接收。 在实现过程中，需要注意的是，由于Android系统的安全限制，...
基于RTP和Android的视频传输的研究实现方法
07-12
### 基于RTP和Android的视频传输的研究实现方法 #### 1. Android及其开发环境 ##### 1.1 Android简介 Android是由Google公司于2007年推出的一款基于Linux内核的操作系统，主要应用于移动设备。它采用开源模式，...
android端RTP实时语音测试用例
06-10
实现了android端实时语音通话，可以本机自连也可以和别的端连接通话，默认的模式是外连模式，要想自连测试需要把Global.java中的sendToSelf静态变量改为true。本例子实现的是局域网的实时语音。
基于RTP和Android的视频传输的研究实现方法_孙松源(pdf)
08-03
详细介绍了利用RTP/RTCP基于android进行视频实时传输的原理。
Android之基于RTP/RTSP即时通讯-Android源码
10-24
该代码主要融合了anychat 的技术核心技术，支持rtp/rtsp流媒体协议，实现视频聊天、可视通话、电视直播、即拍即传等功能。
Android平台下的RTP,RTCP实现
05-26
非原创。 The jlibrtp package contains the core classes of jlibrtp. Most of these classes are protected or private, developers looking to use jlibrtp should only concern themselves with RTPSession - the main session object Participant - participant objects DataFrame - the containers in which data is returned RTPAppIntf - the mininum callback interface RTPCAppIntf - optional interface for receing RTCP packets RTCPAVPFIntf - optional interface for RTP with feedback DebugAppIntf - optional interface for debugging
android视频聊天源码(使用RTP协议,ffmpeg解码)
01-08
可以编议通过,最重要的是不要分
android用live555 rtsp服务器传输camera图像示例代码 1
06-10
在本示例中，我们将讨论如何使用Live555在Android设备上创建一个RTSP服务器，以便将Camera捕获的图像实时传输到网络上的其他客户端。 首先，我们需要了解RTSP的基本概念。RTSP是一种应用层协议，用于控制多媒体数据...
android rstp服务器,将实时Android网络摄像头视频上传到RTP/RTSP服务器
weixin_31156651的博客
05-25 872
您的整体方法听起来正确，但您需要考虑几件事情。So I would like to program an application where the user can record a video and instantly (live) upload the video to a RTP/RTSP Server.>我假设您要上传到RTSP服务器，以便可以将内容重新分发给多个客户端？>...
Android 文件 Rtp
weixin_41107810的博客
08-05 55
如何在 Android 中实现文件 RTP（Real-time Transport Protocol） 如果你是一名刚入行的开发者，可能会对实现“Android 文件 RTP”感到困惑。今天，我将向你详细讲解整个实现过程，并帮助你逐步完成这一任务。 实现流程概述 我们可以将整个实现流程分为以下几个步骤： 步骤 描述 ...
评论 15
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值