手写 Android 录屏直播

简介

观看手游直播时,我们观众端看到的是选手的屏幕上的内容,这是如何实现的呢?这篇博客将手写一个录屏直播 Demo,实现类似手游直播的效果

获取屏幕数据很简单,Android 系统有提供对应的服务,难点在于传输数据到直播服务器,我们使用 RtmpDump 来传输 Rtmp 数据,由于 RtmpDump 使用 C 语言实现,我们还需要用到 NDK 开发,单单用 Java 无法实现哈,当然如果不怕麻烦的话,还可以自己编译 Ffmpeg 实现 Rtmp 推流,B 站开源的 ijkplayer 播放器也是基于 Ffmpeg 来开发的

实现效果

最终我们推流到 B 站直播间,在直播间能够实时看到我们手机屏幕上的画面


image.png

基本流程

  • 获取录屏数据
  • 对数据进行 h264 编码
  • Rtmp 数据包
  • 上传到直播服务器推流地址

获取录屏数据

通过 Intent 获取到 MediaProjectionService,继而获取到 Mediaprojection 的 VirtualCanvas,我们录屏的原始数据就是从中得来的

    private void initLive() {
        mediaProjectionManager = (MediaProjectionManager) getSystemService(Context.MEDIA_PROJECTION_SERVICE);
        Intent screenRecordIntent = mediaProjectionManager.createScreenCaptureIntent();
        startActivityForResult(screenRecordIntent,100);
    }
    
    
        @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        if (requestCode == 100 && resultCode == Activity.RESULT_OK) {
            //MediaProjection--->产生录屏数据
            mediaProjection = mediaProjectionManager.getMediaProjection
                    (resultCode, data);
        }
    }


对数据进行 h264 编码

通过 MediaProjection 获取到的 YUV 裸数据,我们先需要对其进行 h264 编码,此时我们使用原生 MediaCodec 进行硬件编码

    public void start(MediaProjection mediaProjection){
        this.mediaProjection = mediaProjection;
        // 配置 MediaCodec
        MediaFormat mediaFormat = MediaFormat.createVideoFormat(MediaFormat.MIMETYPE_VIDEO_AVC,width,height);
        // 颜色格式
        mediaFormat.setInteger(MediaFormat.KEY_COLOR_FORMAT, MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface);
        mediaFormat.setInteger(MediaFormat.KEY_BIT_RATE, 400_000);
        mediaFormat.setInteger(MediaFormat.KEY_FRAME_RATE, 15);
        // 设置触发关键帧的时间间隔为 2 s
        mediaFormat.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, 2);

        // 创建编码器
        try {
            mediaCodec = MediaCodec.createEncoderByType("video/avc");
            mediaCodec.configure(mediaFormat,null,null,MediaCodec.CONFIGURE_FLAG_ENCODE);
            Surface surface = mediaCodec.createInputSurface();
            mediaProjection.createVirtualDisplay(TAG,width,height,1, DisplayManager.VIRTUAL_DISPLAY_FLAG_PUBLIC
            ,surface,null,null);
        } catch (IOException e) {
            e.printStackTrace();
        }
        start();
    }
    
    
    @Override
    public void run() {
        isLiving = true;
        mediaCodec.start();
        MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();

        while (isLiving){
            //若时间差大于 2 s,则通知编码器,生成 I 帧
            if (System.currentTimeMillis() - timeStamp >= 2000){
                // Bundle 通知 Dsp
                Bundle msgBundle = new Bundle();
                msgBundle.putInt(MediaCodec.PARAMETER_KEY_REQUEST_SYNC_FRAME,0);
                mediaCodec.setParameters(msgBundle);
                timeStamp = System.currentTimeMillis();
            }
            // 接下来就是 MediaCodec 常规操作,获取 Buffer 可用索引,这里不需要获取输出索引,内部已经操作了
            int outputBufferIndex = mediaCodec.dequeueOutputBuffer(bufferInfo,100_000);
            if (outputBufferIndex >=0){
                // 获取到了
                ByteBuffer byteBuffer = mediaCodec.getOutputBuffer(outputBufferIndex);
                byte[] outData = new byte[bufferInfo.size];
                byteBuffer.get(outData);
            }
        }
    }

Rtmp 数据包

经过上面两步,我们获得了编码好的 h264 数据,接下来封装 Rtmp 就比较头疼了(Ndk 的知识都忘得差不多了)

首先我们在项目的 cpp 文件中,把 Rtmpdump 的源代码导入,我们使用 rtmpdump 连接服务器,以及传输 Rtmp 数据,要知道目前手里的数据还是 h264 码流,是无法直接传输,需要封装成 Rtmp 数据包

使用第三方库 Rtmpdump 来实现推流到直播服务器,由于 Rtmpdump 的代码量不是很多,我们直接拷贝源代码到 Android 的 cpp 文件,如果需要用到 Ffmpeg 不能才用该种调用方式了,需要提前编译好 so 库文件

对 Rtmp 暂时不需要做太深刻的理解,因为很容易给自己绕进去,用 Rtmp 传输 h264 数据,那么 sps,pps ,以及关键帧怎么摆放,Rtmp 都已经规定好了,我们就需要使用 NDK 的方式,实现 rtmp 数据的填充

RtmpDump 的使用

image.png
  • 连接服务器
  1. RTMP_Init(RTMP *r) 初始化
  2. RTMP_EnableWrite(RTMP *r) 配置开启数据写入
  3. RTMP_Connect(RTMP *r, RTMPPacket *cp)
  4. RTMP_ConnectStream(RTMP *r, int seekTime)
  • 发送数据
  1. RTMPPacket_Alloc(RTMPPacket *p, int nSize)
  2. RTMP_SendPacket(RTMP *r, RTMPPacket *packet, int queue)
  3. RTMPPacket_Free(RTMPPacket *p)

连接直播服务器

这一步中,需要预先准备直播推流地址,然后实现 native 方法


extern "C" JNIEXPORT jboolean JNICALL
Java_com_bailun_kai_rtmplivedemo_RtmpPack2Remote_connectLiveServer(JNIEnv *env, jobject thiz,
                                                                   jstring url) {
    // 首先 Java 的转成 C 的字符串,不然无法使用
    const char *live_url = env->GetStringUTFChars(url,0);
    int result;

    do {
     // 结构体对象分配内存
     livePack = (LivePack *)(malloc(sizeof(LivePack)));
     // 清空内存上的脏数据
     memset(livePack,0,sizeof(LivePack));
     // Rtmp 申请内存
     livePack->rtmp = RTMP_Alloc();
     RTMP_Init(livePack->rtmp);
     // 设置 rtmp 初始化参数,比如超时时间、url
     livePack->rtmp->Link.timeout = 10;
     LOGI("connect %s", url);

     if (!(result = RTMP_SetupURL(livePack->rtmp,(char *)live_url))){
         break;
     }
     // 开启 Rtmp 写入
     RTMP_EnableWrite(livePack->rtmp);
     LOGI("RTMP_Connect");
     if (!(result = RTMP_Connect(livePack->rtmp,0))){
         break;
     }
     LOGI("RTMP_ConnectStream ");
     if (!(result = RTMP_ConnectStream(livePack->rtmp, 0)))
         break;
     LOGI("connect success");
    }while (0);

    if (!result && livePack){
        free(livePack);
        livePack = nullptr;
    }
    env->ReleaseStringUTFChars(url,live_url);
    return result;
}

发送数据到直播服务器

image.png

有意思的是,Rtmp 协议中不需要传递分隔符(h264 分隔符为 0 0 0 1),并且推流的第一个 Rtmp 包的内容为 sps、pps 等


// 发送 rtmp 数据到服务器
extern "C"
JNIEXPORT jboolean JNICALL
Java_com_bailun_kai_rtmplivedemo_RtmpPack2Remote_sendData2Server(JNIEnv *env, jobject thiz,
                                                                 jbyteArray buffer, jint length,
                                                                 jlong tms) {
    int result;
    // 拷贝数据
    jbyte *bufferArray = env->GetByteArrayElements(buffer, 0);
    result = sendDataInner(bufferArray,length,tms);
    //释放内存
    env->ReleaseByteArrayElements(buffer,bufferArray,0);
    return result;
}



int sendDataInner(jbyte *array, jint length, jlong tms) {
    int result = 0;
    //处理 sps、pps
    if (array[4] == 0x67){
        // 读取 sps,pps 数据,保存到结构体中
       readSpsPps(array,length,livePack);
       return result;
    }


    //处理 I帧,其他帧
    if(array[4] == 0x65){
      RTMPPacket * spsPpsPacket = createRtmpSteramPack(livePack);
      sendPack(spsPpsPacket);
    }

    RTMPPacket* rtmpPacket = createRtmpPack(array,length,tms,livePack);
    result = sendPack(rtmpPacket);
    return result;
}


int sendPack(RTMPPacket *pPacket) {
    int result = RTMP_SendPacket(livePack->rtmp,pPacket,1);
    RTMPPacket_Free(pPacket);
    free(pPacket);
    return result;
}



// 发送 sps ,pps 对应的 Rtmp 包
RTMPPacket *createRtmpSteramPack(LivePack *pack) {
    //  创建 Rtmp 数据包,对应 RtmpDump 库的 RTMPPacket 结构体
    int body_size = 16 + pack->sps_len + pack->pps_len;
    RTMPPacket  *rtmpPacket = static_cast(malloc(sizeof(RTMPPacket)));
    RTMPPacket_Alloc(rtmpPacket,body_size);
    int index = 0;
    rtmpPacket->m_body[index++] = 0x17;
    //AVC sequence header 设置为0x00
    rtmpPacket->m_body[index++] = 0x00;
    //CompositionTime
    rtmpPacket->m_body[index++] = 0x00;
    rtmpPacket->m_body[index++] = 0x00;
    rtmpPacket->m_body[index++] = 0x00;
    //AVC sequence header
    rtmpPacket->m_body[index++] = 0x01;
//    原始 操作

    rtmpPacket->m_body[index++] = pack->sps[1]; //profile 如baseline、main、 high

    rtmpPacket->m_body[index++] = pack->sps[2]; //profile_compatibility 兼容性
    rtmpPacket->m_body[index++] = pack->sps[3]; //profile level
    rtmpPacket->m_body[index++] = 0xFF;//已经给你规定好了
    rtmpPacket->m_body[index++] = 0xE1; //reserved(111) + lengthSizeMinusOne(5位 sps 个数) 总是0xe1
//高八位
    rtmpPacket->m_body[index++] = (pack->sps_len >> 8) & 0xFF;
//    低八位
    rtmpPacket->m_body[index++] = pack->sps_len & 0xff;
//    拷贝sps的内容
    memcpy(&rtmpPacket->m_body[index], pack->sps, pack->sps_len);
    index +=pack->sps_len;
//    pps
    rtmpPacket->m_body[index++] = 0x01; //pps number
//rtmp 协议
    //pps length
    rtmpPacket->m_body[index++] = (pack->pps_len >> 8) & 0xff;
    rtmpPacket->m_body[index++] = pack->pps_len & 0xff;
//    拷贝pps内容
    memcpy(&rtmpPacket->m_body[index], pack->pps, pack->pps_len);
//packaet
//视频类型
    rtmpPacket->m_packetType = RTMP_PACKET_TYPE_VIDEO;
//
    rtmpPacket->m_nBodySize = body_size;
//    视频 04
    rtmpPacket->m_nChannel = 0x04;
    rtmpPacket->m_nTimeStamp = 0;
    rtmpPacket->m_hasAbsTimestamp = 0;
    rtmpPacket->m_headerType = RTMP_PACKET_SIZE_LARGE;
    rtmpPacket->m_nInfoField2 = livePack->rtmp->m_stream_id;
    return rtmpPacket;
}

RTMPPacket *createRtmpPack(jbyte *array, jint length, jlong tms, LivePack *pack) {
    array += 4;
    RTMPPacket *packet = (RTMPPacket *) malloc(sizeof(RTMPPacket));
    int body_size = length + 9;
    RTMPPacket_Alloc(packet, body_size);
    if (array[0] == 0x65) {
        packet->m_body[0] = 0x17;
        LOGI("发送关键帧 data");
    } else{
        packet->m_body[0] = 0x27;
        LOGI("发送非关键帧 data");
    }
//    固定的大小
    packet->m_body[1] = 0x01;
    packet->m_body[2] = 0x00;
    packet->m_body[3] = 0x00;
    packet->m_body[4] = 0x00;

    //长度
    packet->m_body[5] = (length >> 24) & 0xff;
    packet->m_body[6] = (length >> 16) & 0xff;
    packet->m_body[7] = (length >> 8) & 0xff;
    packet->m_body[8] = (length) & 0xff;

    //数据
    memcpy(&packet->m_body[9], array, length);
    packet->m_packetType = RTMP_PACKET_TYPE_VIDEO;
    packet->m_nBodySize = body_size;
    packet->m_nChannel = 0x04;
    packet->m_nTimeStamp = tms;
    packet->m_hasAbsTimestamp = 0;
    packet->m_headerType = RTMP_PACKET_SIZE_LARGE;
    packet->m_nInfoField2 = pack->rtmp->m_stream_id;


    return packet;
}




void readSpsPps(jbyte *array, jint length, LivePack *pack) {
    for (int i = 0; i < length; i++) {
        if (i+4 < length){
            // 找到 pps 的下标
            if (array[i] == 0x00
                && array[i+1] == 0x00
                && array[i+2] == 0x00
                && array[i+3] == 0x01
                && array[i+4] == 0x68
            ){
                // 保存 sps
                livePack->sps_len = i - 4;
                livePack->sps = static_cast(malloc(livePack->sps_len));
                memcpy(livePack->sps,array + 4,livePack->sps_len);
                // 保存 pps
                livePack->pps_len = length -(livePack->sps_len+4) - 4;
                livePack->pps = static_cast(malloc(livePack->pps_len));
                memcpy(livePack->pps,array+4+livePack->sps_len+4,livePack->pps_len);
                LOGI("sps:%d pps:%d", livePack->sps_len, livePack->pps_len);
            }
        }
    }

指针的使用

  • malloc 只管分配内存,并不能对所得的内存进行初始化,所以得到的一片新内存中,其值将是随机的,申请的内存是连续的
  • 返回类型是 void* 类型,void* 表示未确定类型的指针。C/C++ 规定,void* 类型可以强制转换为任何其它类型的指针,malloc 函数返回的是 void * 类型,C++:p = malloc (sizeof(int)); 则程序无法通过编译,报错:“不能将 void* 赋值给 int * 类型变量”。所以必须通过 (int *) 来将强制转换

总结

首先我们通过系统服务拿到手机屏幕的画面,此时取到的原始数据还无法进行网络传输,在对其进行 h264 编码后,封装 Rtmp 包,然后按照 Rtmp 协议规定的方式进行传输

相关链接

直播 I帧设置的意义

Cmake 基础中的基础

C语言 malloc()、memcpy()、free()

java 并发之阻塞队列 LinkedBlockingQueue

谈谈LinkedBlockingQueue

C 移植到 Java 中,byte[] 与其他数据类型的转换

在 Android Jni 编程中如何接收和返回 Java 不同类型变量或对象

你可能感兴趣的:(手写 Android 录屏直播)