流媒体协议RTMP推流demo-安卓端

Android RTMP 录屏直播推流:MediaProjection 录屏 + MediaCodec 硬编 H264/AAC + librtmp 推流。

老样子,先源码、效果图,再详解

源码地址

https://gitee.com/flying-guy/practical-demo/blob/master/VideoTest/GameLive/src/main/java/com/lwj/gamelive/MainActivity.java

效果图

demo推流,douyu拉流

推流端:摄像头、本应用、其他应用。

网页douyu拉流端

压后台OK、测试的时候网络不好,整体延迟2~4s。

目录

[一、Demo 架构设计](#一、Demo 架构设计)

整体架构

数据流

分层架构

各层职责

线程模型

队列与背压

生命周期管理

二、核心代码

[AndroidManifest.xml(权限 + 前台服务注册)](#AndroidManifest.xml(权限 + 前台服务注册))

[ScreenLive.java(推流服务 + 队列)](#ScreenLive.java(推流服务 + 队列))

[VideoCodec.java(录屏 + H264 编码)](#VideoCodec.java(录屏 + H264 编码))

[AudioCodec.java(录音 + AAC 编码)](#AudioCodec.java(录音 + AAC 编码))

[native-lib.cpp(JNI 桥接层)](#native-lib.cpp(JNI 桥接层))

[packt.h(RTMP 包构造)](#packt.h(RTMP 包构造))

三、遇到的问题及解决方案

[1. targetSdk 28 → 34 + 前台服务改造](#1. targetSdk 28 → 34 + 前台服务改造)

[2. abiFilters 加 arm64-v8a](#2. abiFilters 加 arm64-v8a)

[3. MediaProjection registerCallback](#3. MediaProjection registerCallback)

[4. H264 NAL 格式解析修复(Annex-B)](#4. H264 NAL 格式解析修复(Annex-B))

[5. 视频比特率提升](#5. 视频比特率提升)

[6. 启用音频推流](#6. 启用音频推流)

[7. AudioCodec 缓冲区溢出修复](#7. AudioCodec 缓冲区溢出修复)

[四、RTMP 源码架构设计](#四、RTMP 源码架构设计)

文件归属

[librtmp 模块划分](#librtmp 模块划分)

核心数据结构

连接生命周期(推流端)

RTMP协议整体结构图

[Message 怎么变成 Chunk](#Message 怎么变成 Chunk)

其他层简述

[AMF 编解码](#AMF 编解码)

发送音视频数据

构建

五、抗弱网能力

现有自带的弱网相关机制

[RTMP 协议层面的弱网局限](#RTMP 协议层面的弱网局限)

后续演进的业务抗弱网能力

第一档:在现有架构上加(改动小)

第二档:换传输层(改动中)

六、流媒体协议体系

流媒体格式

[1. 设计目标:实时传输音视频](#1. 设计目标:实时传输音视频)

[2. 流复用 + 独立通道](#2. 流复用 + 独立通道)

[3. 消息分块(Chunk)+ 时间戳](#3. 消息分块(Chunk)+ 时间戳)

[4. 会话控制命令集](#4. 会话控制命令集)

[5. 封装流媒体格式(FLV Tag)](#5. 封装流媒体格式(FLV Tag))

[6. 推/拉两种模式](#6. 推/拉两种模式)

[7. 完整的协议分层](#7. 完整的协议分层)

[对比:为什么 HTTP 传文件不是流媒体协议](#对比:为什么 HTTP 传文件不是流媒体协议)

[为什么拉流一般不用 RTMP](#为什么拉流一般不用 RTMP)


一、Demo 架构设计

整体架构

java 复制代码
MainActivity (授权)
  └─ startForegroundService(ScreenLive)
       ├─ startForeground (mediaProjection 类型)
       ├─ getMediaProjection + registerCallback
       └─ 工作线程
            ├─ connect(url)              → native librtmp 连接 RTMP 服务器
            ├─ VideoCodec.startLive      → MediaProjection 录屏 + MediaCodec H264 编码
            ├─ AudioCodec.startLive      → AudioRecord 录音 + MediaCodec AAC 编码
            └─ 循环 sendData             → native librtmp 发送 RTMP 包

数据流

java 复制代码
MediaProjection → VirtualDisplay → Surface → MediaCodec(H264) → Annex-B NAL → packt.h 转换 → RTMP 包 → librtmp 发送
AudioRecord → PCM → MediaCodec(AAC) → AAC 帧 → packt.h 组装 → RTMP 包 → librtmp 发送

分层架构

java 复制代码
┌─────────────────────────────────────────────────────┐
│  Java 层                                             │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐          │
│  │MainActivity│  │ScreenLive│  │VideoCodec│          │
│  │ (授权入口) │  │ (Service) │  │ (录屏编码)│          │
│  └──────────┘  └──────────┘  └──────────┘          │
│                     │          ┌──────────┐          │
│                     │          │AudioCodec│          │
│                     │          │ (录音编码)│          │
│                     │          └──────────┘          │
│                     │          ┌───────────┐         │
│                     └──────────│RTMPPackage│         │
│                     队列枢纽    │ (数据包)   │         │
│                                └───────────┘         │
├─────────────────────────────────────────────────────┤
│  JNI 层 (native-lib.cpp)                             │
│  connect() / disConnect() / sendData()               │
│  sendVideo() / sendAudio()                           │
├─────────────────────────────────────────────────────┤
│  Native 层                                           │
│  ┌──────────────┐  ┌──────────────────────────┐     │
│  │ packt.h       │  │ librtmp/ (开源库)         │     │
│  │ (RTMP包构造)  │  │ RTMP协议核心              │     │
│  └──────────────┘  └──────────────────────────┘     │
└─────────────────────────────────────────────────────┘

各层职责

Java 层:

  • MainActivity:请求 MediaProjection 授权,授权后 startForegroundService(ScreenLive)

  • ScreenLive(Service):前台服务管理 MediaProjection 生命周期;持有 LinkedBlockingQueue<RTMPPackage> 推流队列;工作线程负责 connect → 循环 take + sendData → disConnect

  • VideoCodec:MediaProjection 录屏 → VirtualDisplay → Surface → MediaCodec(H264) 编码,输出 Annex-B NAL,封装成 RTMPPackage(type=VIDEO) 入队
  • AudioCodec:AudioRecord 录音 → MediaCodec(AAC) 编码,输出 AAC 帧,封装成 RTMPPackage(type=AUDIO_HEAD/AUDIO_DATA) 入队
  • RTMPPackage:数据包封装(buffer + type + tms 时间戳),VIDEO=0 / AUDIO_HEAD=1 / AUDIO_DATA=2

JNI 层 (native-lib.cpp,本项目代码):

  • connect(url):调 librtmp 的 RTMP_Alloc → RTMP_SetupURL → RTMP_EnableWrite → RTMP_Connect → RTMP_ConnectStream

  • disConnect():RTMP_Close → RTMP_Free + 释放 SPS/PPS

  • sendData(data, len, type, tms):type=0 走 sendVideo(解析 NAL 类型,SPS/PPS 缓存 + 发送,IDR 先发 SPS/PPS 包再发视频包),其他走 sendAudio

Native 层:

  • packt.h(本项目代码):RTMP 包构造------prepareVideo(Annex-B 解析 SPS/PPS)、createSpsPpsPackage(AVC sequence header)、createVideoPackage(Annex-B → AVC 长度前缀)、createAudioPackage(AAC 包)

  • librtmp/(开源库,见下方 RTMP 源码架构):RTMP 协议核心,TCP 连接、握手、AMF 编解码、chunk 发送

线程模型

java 复制代码
主线程                  ScreenLive工作线程           VideoCodec线程        AudioCodec线程
  │                        │                          │                     │
  │ startForegroundService │                          │                     │
  │───────────────────────>│                          │                     │
  │                        │ connect(url) [native]     │                     │
  │                        │ videoCodec.startLive()    │                     │
  │                        │──────────────────────────>│                     │
  │                        │ audioCodec.startLive()    │                     │
  │                        │─────────────────────────────────────────────────>│
  │                        │                          │ MediaCodec编码       │ AudioRecord录音
  │                        │                          │ addPackage()         │ addPackage()
  │                        │                          │─────┐               │─────┐
  │                        │ while: take() + sendData │     │               │     │
  │                        │<─────────────────────────┘     │               │     │
  │                        │                              │               │     │
  │                        │ disConnect + stopSelf         │               │     │
  • 主线程:Activity 授权 + Service 生命周期

  • ScreenLive 工作线程:连接 RTMP → 循环取队列发包 → 断开

  • VideoCodec 线程(LiveTaskManager 线程池):MediaCodec 编码循环,每 2s 强制请求关键帧

  • AudioCodec 线程(LiveTaskManager 线程池):AudioRecord 录音 + AAC 编码循环

队列与背压

java 复制代码
VideoCodec ──addPackage──>  LinkedBlockingQueue  <──addPackage── AudioCodec
                               (容量无上限)
                                  │
                           checkDrop: size > 200
                           时丢弃旧包
                                  │
                           take() → sendData [native]
  • LinkedBlockingQueue<RTMPPackage>:生产者(VideoCodec/AudioCodec)→ 消费者(ScreenLive 工作线程)

  • checkDrop():队列 > 200 时丢弃最旧包,防止编码比推流快时内存堆积

  • RTMPPackage.EMPTY_PACKAGE:空包作为停止信号(stopLive 时入队,take 到空包退出循环)

生命周期管理

java 复制代码
Service.onStartCommand
  ├─ startForeground (mediaProjection 类型)
  ├─ getMediaProjection
  ├─ registerCallback (onStop → stopLive)
  └─ startWork (工作线程)
       ├─ connect
       ├─ VideoCodec.startLive → AudioCodec.startLive
       ├─ while: take + sendData
       └─ 退出: VideoCodec.stopLive → AudioCodec.stopLive → disConnect → stopForeground → stopSelf

Service.onDestroy → stopLive (入队空包 + isLiving=false)

释放顺序:先停编码器(VideoCodec/AudioCodec stop+release)→ 断开 RTMP(RTMP_Close+Free)→ 停前台服务。


二、核心代码

MainActivity.java(授权入口)

java 复制代码
/**
 * rtmp直播推流学习(硬编)
 * <p>
 * Android 14+: 录屏改为由 ScreenLive 前台服务(mediaProjection)执行,
 * Activity 只负责请求 MediaProjection 授权,授权后 startForegroundService。
 */
public class MainActivity extends AppCompatActivity {

    private static final String TAG = "MainActivity";
    private static final int REQUEST_SCREEN_CAPTURE = 100;

    private Button btnStartLive;
    private Button btnStopLive;

    // 斗鱼 rtmp 推流地址
    private final String rtmpUrl = "rtmp://...";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        btnStartLive = findViewById(R.id.btn_start_live);
        btnStopLive = findViewById(R.id.btn_stop_live);
        btnStartLive.setOnClickListener(onClickListener);
        btnStopLive.setOnClickListener(onClickListener);
        checkPermission();
    }

    public void checkPermission() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            requestPermissions(new String[]{
                    Manifest.permission.READ_EXTERNAL_STORAGE,
                    Manifest.permission.WRITE_EXTERNAL_STORAGE,
                    Manifest.permission.RECORD_AUDIO,
                    Manifest.permission.POST_NOTIFICATIONS
            }, 1);
        }
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        Log.d(TAG, "onActivityResult: ");
        if (requestCode == REQUEST_SCREEN_CAPTURE && resultCode == RESULT_OK && data != null) {
            Intent service = new Intent(this, ScreenLive.class);
            service.putExtra("url", rtmpUrl);
            service.putExtra("resultCode", resultCode);
            service.putExtra("data", data);
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
                startForegroundService(service);
            } else {
                startService(service);
            }
        }
    }

    View.OnClickListener onClickListener = new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            switch (v.getId()) {
                case R.id.btn_start_live:
                    startLive();
                    break;
                case R.id.btn_stop_live:
                    stopLive();
                    break;
                default:
            }
        }
    };

    public void startLive() {
        Log.d(TAG, "startLive: ");
        MediaProjectionManager mpm = (MediaProjectionManager) getSystemService(Context.MEDIA_PROJECTION_SERVICE);
        Intent intent = mpm.createScreenCaptureIntent();
        startActivityForResult(intent, REQUEST_SCREEN_CAPTURE);
    }

    public void stopLive() {
        Log.d(TAG, "stopLive: ");
        stopService(new Intent(this, ScreenLive.class));
    }
}

AndroidManifest.xml(权限 + 前台服务注册)

XML 复制代码
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.lwj.gamelive">

    <!-- 网络 -->
    <uses-permission android:name="android.permission.INTERNET"/>
    <!-- 录音 -->
    <uses-permission android:name="android.permission.RECORD_AUDIO" />
    <!-- 存储 -->
    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
    <!-- 前台服务(Android 14+ 必须声明类型对应权限)-->
    <uses-permission android:name="android.permission.FOREGROUND_SERVICE"/>
    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PROJECTION"/>
    <!-- 通知(Android 13+ 前台服务要发通知)-->
    <uses-permission android:name="android.permission.POST_NOTIFICATIONS"/>

    <application ...>
        <activity android:name=".MainActivity" android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

        <!-- 录屏前台服务:foregroundServiceType=mediaProjection -->
        <service
            android:name=".ScreenLive"
            android:foregroundServiceType="mediaProjection"
            android:exported="false" />
    </application>
</manifest>

ScreenLive.java(推流服务 + 队列)

java 复制代码
/**
 * Android 14+(API 34)要求 MediaProjection 录屏必须在前台服务中运行,
 * 因此从 Thread 改造为 mediaProjection 类型的前台 Service。
 * native 方法(connect/disConnect/sendData)与推流队列保持不变。
 */
public class ScreenLive extends Service {

    private static final String TAG = "ScreenLive";
    private static final String CHANNEL_ID = "screen_live_channel";
    private static final int NOTIFICATION_ID = 1001;

    static {
        System.loadLibrary("native-lib");
    }

    private String url;
    private MediaProjectionManager mMediaProjectionManager;
    private boolean isLiving;
    private final LinkedBlockingQueue<RTMPPackage> mRTMPPackageLinkedBlockingQueue = new LinkedBlockingQueue<>();
    private MediaProjection mMediaProjection;
    private VideoCodec videoCodec;
    private AudioCodec audioCodec;
    private Thread workThread;

    @Override
    public void onCreate() {
        super.onCreate();
        mMediaProjectionManager = (MediaProjectionManager) getSystemService(Context.MEDIA_PROJECTION_SERVICE);
        createNotificationChannel();
    }

    private void createNotificationChannel() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            NotificationChannel channel = new NotificationChannel(CHANNEL_ID, "屏幕直播", NotificationManager.IMPORTANCE_LOW);
            NotificationManager nm = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
            nm.createNotificationChannel(channel);
        }
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        if (intent == null) {
            return START_NOT_STICKY;
        }
        url = intent.getStringExtra("url");
        int resultCode = intent.getIntExtra("resultCode", 0);
        Intent data = intent.getParcelableExtra("data");

        // 必须先 startForeground(mediaProjection 类型),再 getMediaProjection,否则 Android 14 会拒绝
        android.app.Notification notification = new NotificationCompat.Builder(this, CHANNEL_ID)
                .setContentTitle("正在录屏直播")
                .setContentText("RTMP 推流中")
                .setSmallIcon(android.R.drawable.ic_media_play)
                .setOngoing(true)
                .build();
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
            startForeground(NOTIFICATION_ID, notification, ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PROJECTION);
        } else {
            startForeground(NOTIFICATION_ID, notification);
        }

        mMediaProjection = mMediaProjectionManager.getMediaProjection(resultCode, data);
        if (mMediaProjection == null) {
            Log.e(TAG, "getMediaProjection failed");
            stopForeground(true);
            stopSelf();
            return START_NOT_STICKY;
        }
        // Android 14+ 要求 createVirtualDisplay 前必须注册 Callback
        mMediaProjection.registerCallback(new MediaProjection.Callback() {
            @Override
            public void onStop() {
                Log.d(TAG, "MediaProjection onStop");
                stopLive();
            }
        }, new Handler(Looper.getMainLooper()));
        startWork();
        return START_NOT_STICKY;
    }

    private void startWork() {
        workThread = new Thread(() -> {
            // 1、连接 RTMP 服务器
            if (!connect(url)) {
                Log.e(TAG, "connect failed");
                stopForeground(true);
                stopSelf();
                return;
            }
            isLiving = true;
            videoCodec = new VideoCodec(ScreenLive.this);
            videoCodec.startLive(mMediaProjection);
            audioCodec = new AudioCodec(ScreenLive.this);
            audioCodec.startLive();
            boolean isSend = true;
            while (isLiving && isSend) {
                RTMPPackage rtmpPackage = null;
                try {
                    checkDrop();
                    rtmpPackage = mRTMPPackageLinkedBlockingQueue.take();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (null == rtmpPackage) {
                    Log.d(TAG, "run: null");
                    break;
                }
                if (rtmpPackage.getBuffer() != null && rtmpPackage.getBuffer().length != 0) {
                    isSend = sendData(rtmpPackage.getBuffer(), rtmpPackage.getBuffer().length, rtmpPackage.getType(), rtmpPackage.getTms());
                    Log.d(TAG, "run: send status = " + isSend);
                }
            }

            Log.d(TAG, "run: stop live");
            isLiving = false;
            if (videoCodec != null) {
                videoCodec.stopLive();
            }
            if (audioCodec != null) {
                audioCodec.stopLive();
            }
            mRTMPPackageLinkedBlockingQueue.clear();
            disConnect();
            stopForeground(true);
            stopSelf();
        }, "ScreenLive");
        workThread.start();
    }

    public void stopLive() {
        addPackage(RTMPPackage.EMPTY_PACKAGE);
        isLiving = false;
    }

    @Override
    public void onDestroy() {
        stopLive();
        super.onDestroy();
    }

    public void addPackage(RTMPPackage rtmpPackage) {
        if (!isLiving) {
            return;
        }
        mRTMPPackageLinkedBlockingQueue.add(rtmpPackage);
    }

    private void checkDrop() throws InterruptedException {
        Log.d(TAG, "checkDrop: ");
        while (mRTMPPackageLinkedBlockingQueue.size() > 200) {
            mRTMPPackageLinkedBlockingQueue.take();
        }
    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    private native boolean connect(String url);

    private native void disConnect();

    private native static boolean sendData(byte[] data, int len, int type, long tms);
}

VideoCodec.java(录屏 + H264 编码)

java 复制代码
public class VideoCodec extends Thread {

    private MediaProjection mMediaProjection;
    private MediaCodec mMediaCodec;
    private VirtualDisplay mVirtualDisplay;
    private boolean isLiving;
    private long timeStamp;
    private long startTime;
    private ScreenLive mScreenLive;

    public VideoCodec(ScreenLive screenLive) {
        mScreenLive = screenLive;
    }

    public void startLive(MediaProjection mediaProjection) {
        mMediaProjection = mediaProjection;
        // 修复:统一分辨率,编码器和VirtualDisplay使用相同的720x1280
        // 之前编码器是1080x1920,VirtualDisplay是720x1280,导致尺寸不匹配
        int width = 720;
        int height = 1280;

        //配置编码参数
        MediaFormat videoFormat = MediaFormat.createVideoFormat(MediaFormat.MIMETYPE_VIDEO_AVC, width, height);
        videoFormat.setInteger(MediaFormat.KEY_COLOR_FORMAT, MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface);
        videoFormat.setInteger(MediaFormat.KEY_BIT_RATE, 1_200_000);
        videoFormat.setInteger(MediaFormat.KEY_FRAME_RATE, 20);
        videoFormat.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, 2);
        videoFormat.setInteger(MediaFormat.KEY_COLOR_FORMAT, MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface);
        try {
            //创建编码器
            mMediaCodec = MediaCodec.createEncoderByType(MediaFormat.MIMETYPE_VIDEO_AVC);
            mMediaCodec.configure(videoFormat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
            //从编码器创建一个画布,画布上的图像会被编码器自动编码
            Surface surface = mMediaCodec.createInputSurface();
            // 修复:VirtualDisplay分辨率与编码器一致
            mVirtualDisplay = mMediaProjection.createVirtualDisplay("screen-codec", width, height, 1, DisplayManager.VIRTUAL_DISPLAY_FLAG_PUBLIC, surface, null, null);
        } catch (IOException e) {
            e.printStackTrace();
        }
        LiveTaskManager.getInstance().execute(this);
    }

    public void stopLive() {
        isLiving = false;
        try {
            join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        isLiving = true;
        mMediaCodec.start();
        MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
        while (isLiving) {
            if (timeStamp != 0) {
                //2000毫秒后,MediaCodec虽然设置了关键帧间隔,但是没用,需要手动强制请求
                if (System.currentTimeMillis() - timeStamp >= 2000) {
                    Bundle params = new Bundle();
                    //立即刷新,让下一帧是关键帧
                    params.putInt(MediaCodec.PARAMETER_KEY_REQUEST_SYNC_FRAME, 0);
                    mMediaCodec.setParameters(params);
                    timeStamp = System.currentTimeMillis();
                }
            } else {
                timeStamp = System.currentTimeMillis();
            }
            int index = mMediaCodec.dequeueOutputBuffer(bufferInfo, 100000);
            if (index >= 0) {
                ByteBuffer buffer = mMediaCodec.getOutputBuffer(index);
                byte[] outData = new byte[bufferInfo.size];
                buffer.get(outData);
                //这样也能拿到sps pps
//                ByteBuffer sps = mMediaCodec.getOutputFormat().getByteBuffer("csd-0");
//                ByteBuffer pps = mMediaCodec.getOutputFormat().getByteBuffer("csd-1");
                if (startTime == 0) {
                    //微秒转为毫秒
                    startTime = bufferInfo.presentationTimeUs / 1000;
                }
                RTMPPackage rtmpPackage = new RTMPPackage();
                rtmpPackage.setBuffer(outData);
                rtmpPackage.setType(RTMPPackage.RTMP_PACKET_TYPE_VIDEO);
                long tms = (bufferInfo.presentationTimeUs / 1000) - startTime;
                rtmpPackage.setTms(tms);
                //mScreenLive = new ScreenLive();
                mScreenLive.addPackage(rtmpPackage);
                mMediaCodec.releaseOutputBuffer(index, false);
            }
        }
        isLiving = false;
        startTime = 0;
        mMediaCodec.stop();
        mMediaCodec.release();
        mMediaCodec = null;
        mVirtualDisplay.release();
        mVirtualDisplay = null;
        super.run();
    }
}

AudioCodec.java(录音 + AAC 编码)

java 复制代码
public class AudioCodec extends Thread {

    private static final String TAG = "AudioCodec";

    private final ScreenLive mScreenLive;

    private MediaCodec mMediaCodec;
    private AudioRecord mAudioRecord;
    private boolean isRecording;

    private long startTime;
    private int minBufferSize;

    public AudioCodec(ScreenLive screenLive) {
        this.mScreenLive = screenLive;
    }

    @Override
    public void run() {
        isRecording = true;
        RTMPPackage rtmpPackage = new RTMPPackage();
        byte[] audioDecoderSpecificInfo = {0x12, 0x08};
        rtmpPackage.setBuffer(audioDecoderSpecificInfo);
        rtmpPackage.setType(RTMPPackage.RTMP_PACKET_TYPE_AUDIO_HEAD);
        mScreenLive.addPackage(rtmpPackage);
        mAudioRecord.startRecording();
        MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
        byte[] buffer = new byte[minBufferSize];
        while (isRecording) {
            int len = mAudioRecord.read(buffer, 0, buffer.length);
            if (len <= 0) {
                Log.d(TAG, "run: len < 0");
                continue;
            }
            //立即得到有效输入缓冲区
            int index = mMediaCodec.dequeueInputBuffer(0);
            Log.d(TAG, "run: before in buffer index = " + index);
            if (index >= 0) {
                ByteBuffer inputBuffer = mMediaCodec.getInputBuffer(index);
                inputBuffer.clear();
                Log.d(TAG, "run: inputBuffer = " + inputBuffer.toString() + ", buffer = " + buffer + ", len = " + len);
                inputBuffer.put(buffer, 0, len);
                //填充数据后再加入队列
                mMediaCodec.queueInputBuffer(index, 0, len,
                        System.nanoTime() / 1000, 0);
            }
            index = mMediaCodec.dequeueOutputBuffer(bufferInfo, 0);
            Log.d(TAG, "run: after out buffer index = " + index);
            while (index >= 0 && isRecording) {
                ByteBuffer outputBuffer = mMediaCodec.getOutputBuffer(index);
                byte[] outData = new byte[bufferInfo.size];
                outputBuffer.get(outData);
                if (startTime == 0) {
                    startTime = bufferInfo.presentationTimeUs / 1000;
                }
                rtmpPackage = new RTMPPackage();
                rtmpPackage.setBuffer(outData);
                rtmpPackage.setType(RTMPPackage.RTMP_PACKET_TYPE_AUDIO_DATA);
                long tms = (bufferInfo.presentationTimeUs / 1000) - startTime;
                rtmpPackage.setTms(tms);
                mScreenLive.addPackage(rtmpPackage);
                mMediaCodec.releaseOutputBuffer(index, false);
                index = mMediaCodec.dequeueOutputBuffer(bufferInfo, 0);
            }
        }
        mAudioRecord.stop();
        mAudioRecord.release();
        mAudioRecord = null;

        mMediaCodec.stop();
        mMediaCodec.release();
        mMediaCodec = null;
        startTime = 0;
        isRecording = false;
    }

    @SuppressLint("MissingPermission")
    public void startLive() {
        // 先算 minBufferSize,用于设置编码器输入缓冲区和录音缓冲区
        minBufferSize = AudioRecord.getMinBufferSize(44100, AudioFormat.CHANNEL_IN_MONO, AudioFormat.ENCODING_PCM_16BIT);
        Log.d(TAG, "startLive: minBufferSize = " + minBufferSize);
        MediaFormat audioFormat = MediaFormat.createAudioFormat(MediaFormat.MIMETYPE_AUDIO_AAC, 44100, 1);
        audioFormat.setInteger(MediaFormat.KEY_AAC_PROFILE, MediaCodecInfo.CodecProfileLevel.AACObjectLC);
        audioFormat.setInteger(MediaFormat.KEY_BIT_RATE, 64_000);
        audioFormat.setInteger(MediaFormat.KEY_MAX_INPUT_SIZE, minBufferSize);
        try {
            mMediaCodec = MediaCodec.createEncoderByType(MediaFormat.MIMETYPE_AUDIO_AAC);
            mMediaCodec.configure(audioFormat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
            mMediaCodec.start();
            /*
             * 创建录音对象
             * 麦克风 + 采样 + 单声道 + 16位pcm + 缓冲区大小
             * */
            mAudioRecord = new AudioRecord(MediaRecorder.AudioSource.MIC, 44100
                    , AudioFormat.CHANNEL_IN_MONO, AudioFormat.ENCODING_PCM_16BIT, minBufferSize);
        } catch (IOException e) {
            e.printStackTrace();
        }
        LiveTaskManager.getInstance().execute(this);
    }

    public void stopLive() {
        isRecording = false;
        try {
            join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

native-lib.cpp(JNI 桥接层)

cpp 复制代码
#include <jni.h>
#include <string>
#include "packt.h"

extern "C" {
   #include "librtmp/rtmp.h"
}

RTMP *rtmp = 0;
Live *live = 0;

extern "C" jboolean
Java_com_lwj_gamelive_ScreenLive_connect(JNIEnv *env, jobject instance, jstring url_) {
    const char *url = env->GetStringUTFChars(url_, 0);
    int ret;
    do {
        live = (Live *) malloc(sizeof(Live));
        memset(live,0,sizeof(Live));

        live->rtmp = RTMP_Alloc();
        RTMP_Init(live->rtmp);
        live->rtmp->Link.timeout = 10;
        LOGI("connect %s", url);
        ret = RTMP_SetupURL(live->rtmp,(char *) url);
        if(!ret) {
            LOGI("setup URL error:%s",url);
            break;
        }
        RTMP_EnableWrite(live->rtmp);
        ret = RTMP_Connect(live->rtmp,0);
        if(!ret) {
            LOGI("connect error:%s",url);
            break;
        }
        ret = RTMP_ConnectStream(live->rtmp,0);
        if(!ret) {
            LOGI("connectStream error:%s",url);
            break;
        }
        LOGI("connect success");
    } while(0);

    env->ReleaseStringUTFChars(url_,url);
    return ret;
}

extern "C" void
Java_com_lwj_gamelive_ScreenLive_disConnect(JNIEnv *env, jobject instance) {
    if(live) {
       if (live->rtmp) {
           RTMP_Close(live->rtmp);
           RTMP_Free(live->rtmp);
       }
       if (live->sps) {
           free(live->sps);
       }
       if (live->pps) {
           free(live->pps);
       }
       free(live);
       live = 0;
    }

}

int sendPackage(RTMPPacket *packet) {
    LOGI("sendPackage");
    int r = RTMP_SendPacket(live->rtmp, packet, 1);
    RTMPPacket_Free(packet);
    free(packet);
    return r;
}

int sendVideo(int8_t *buf, int len, long tms) {
    LOGI("sendVideo: len = %d", len);
    int ret = 0;
    do {
        // 修复:MediaCodec输出的是AVCC格式,使用4字节长度前缀
        // [4字节长度][NAL header][NAL data]
        // NAL类型: 7=SPS, 8=PPS, 5=IDR(关键帧), 1=non-IDR

        if (len < 5) {
            LOGI("Invalid video data, too short");
            break;
        }

        // 读取NAL类型 (第5个字节的后5位)
        int nalType = buf[4] & 0x1F;
        LOGI("NAL type: %d", nalType);

        if (nalType == 7) { // SPS
            // 解析并缓存SPS/PPS
            if (live && (!live->sps || !live->pps)) {
                LOGI("Parsing SPS/PPS");
                ret = prepareVideo(buf, len, live);
            }
        } else if (nalType == 8) { // PPS
            // PPS通常和SPS一起,不需要单独处理
            ret = 1;
        } else {
            // 视频帧数据 (IDR=5 或 non-IDR=1)
            if (nalType == 5) { // IDR关键帧
                // 先发送SPS/PPS
                if (live->sps && live->pps) {
                    RTMPPacket *spsPpsPacket = createSpsPpsPackage(live);
                    ret = sendPackage(spsPpsPacket);
                    if (!ret) {
                        LOGI("Failed to send SPS/PPS");
                        break;
                    }
                }
            }

            // 发送视频帧
            RTMPPacket *packet2 = createVideoPackage(buf, len, tms, live);
            if (packet2) {
                ret = sendPackage(packet2);
            } else {
                ret = 0;
            }
        }
    }while(0);
        return ret;
}

int sendAudio(int8_t *buf, int len, int type, long tms) {
    LOGI("sendAudio: len = %d", len);
    RTMPPacket *packet = createAudioPackage(buf,len,type,tms,live);
    return sendPackage(packet);
}

extern "C" jboolean
Java_com_lwj_gamelive_ScreenLive_sendData(JNIEnv *env, jclass instance, jbyteArray data_, jint len, jint type, jlong tms) {
jbyte *data = env->GetByteArrayElements(data_, NULL);
LOGI("发送数据:%d",type);
int ret = 1;
switch (type) {
    case 0: //发送视频数据
        ret = sendVideo(data,len,tms);
        break;
    default: //发送音频数据
        ret = sendAudio(data,len,type,tms);
        break;
}
env->ReleaseByteArrayElements(data_, data, 0);
return ret;
}

packt.h(RTMP 包构造)

cpp 复制代码
#ifndef MEDIARECODER_PACKT_H
#define MEDIARECODER_PACKT_H

#include <android/log.h>

#define LOGI(...) __android_log_print(ANDROID_LOG_INFO,"RTMP",__VA_ARGS__)

extern "C" {
   #include "librtmp/rtmp.h"
}

typedef struct {
    int16_t sps_len;
    int16_t pps_len;
    int8_t *sps;
    int8_t *pps;
    RTMP *rtmp;
} Live;

//带sps和pps的packet
RTMPPacket *createSpsPpsPackage(Live *live) {
    LOGI("createSpsPpsPackage");
    int body_size = 16 + live->sps_len + 3 + live->pps_len;
    RTMPPacket *packet = (RTMPPacket *) malloc(sizeof(RTMPPacket));
    RTMPPacket_Alloc(packet, body_size);
    int i = 0;
    //AVC sequence header 与IDR一样
    packet->m_body[i++] = 0x17;
    //AVC sequence header 设置为0x00
    packet->m_body[i++] = 0x00;
    //CompositionTime
    packet->m_body[i++] = 0x00;
    packet->m_body[i++] = 0x00;
    packet->m_body[i++] = 0x00;
    //AVC sequence header
    packet->m_body[i++] = 0x01; //configurationVersion 版本号1
    packet->m_body[i++] = live->sps[1]; //profile 如baseline、main、 high
    packet->m_body[i++] = live->sps[2]; //profile_compatibility兼容性
    packet->m_body[i++] = live->sps[3]; //profile level
    packet->m_body[i++] = 0xFF; //reserved (111111) + lengthSizeMinusOne (2位 nal长度) 总是

    //sps
    packet->m_body[i++] = 0xE1; //reserved (111) + lengthSizeMinusOne (5位 sps 个数) 总是0xe1
    //sps length 2字节
    packet->m_body[i++] = (live->sps_len >> 8) & 0xff; //第0个字节 高8位
    packet->m_body[i++] = live->sps_len & 0xff; //第1个字节 低8位
    memcpy(&packet->m_body[i], live->sps, live->sps_len); //拷贝sps的内容
    i += live->sps_len;

    //pps
    packet->m_body[i++] = 0x01; //pps number
    //pps length
    packet->m_body[i++] = (live->pps_len >> 8) & 0xff;
    packet->m_body[i++] = live->pps_len & 0xff;
    memcpy(&packet->m_body[i], live->pps, live->pps_len); //拷贝pps的内容

    packet->m_packetType = RTMP_PACKET_TYPE_VIDEO;
    packet->m_nBodySize = body_size;
    packet->m_nChannel = 0x04;
    packet->m_nTimeStamp = 0;
    packet->m_hasAbsTimestamp = 0;
    packet->m_headerType = RTMP_PACKET_SIZE_LARGE;
    packet->m_nInfoField2 = live->rtmp->m_stream_id;
    return packet;
}

RTMPPacket *createAudioPackage(int8_t *buf, const int len,const int type, const long tms, Live *live) {
    //组装音频包 两个字节是固定的 如果是第一次发 就是01 后面是00或者01 aac
    int body_size = len + 2;
    RTMPPacket *packet = (RTMPPacket *) malloc(sizeof(RTMPPacket));
    RTMPPacket_Alloc(packet, body_size);

    packet->m_body[0] = 0xAF;
    packet->m_body[1] = 0x01;
    //解码信息
    if (type == 1) {
        packet->m_body[1] = 0x00;
    }
    memcpy(&packet->m_body[2],buf,len);

    packet->m_packetType = RTMP_PACKET_TYPE_AUDIO;
    packet->m_nBodySize = body_size;
    packet->m_nChannel = 0x05;
    packet->m_nTimeStamp = tms;
    packet->m_hasAbsTimestamp = 0;
    packet->m_headerType = RTMP_PACKET_SIZE_LARGE;
    packet->m_nInfoField2 = live->rtmp->m_stream_id;
    return packet;
}

//缓存sps和pps信息
// MediaCodec 输出的是 Annex-B 格式,使用 00 00 00 01 start code 分隔 NAL
// NAL unit type: 7=SPS, 8=PPS, 5=IDR, 1=non-IDR
int prepareVideo(int8_t *data, int len, Live *live) {
    LOGI("prepareVideo");
    // Annex-B: [00 00 00 01][NAL header][NAL data][00 00 00 01][NAL header][NAL data]...
    int offset = 0;
    while (offset + 4 < len) {
        if (data[offset] == 0 && data[offset+1] == 0 && data[offset+2] == 0 && data[offset+3] == 1) {
            int nalStart = offset + 4;
            if (nalStart >= len) break;
            int nalType = data[nalStart] & 0x1F;
            // 找下一个 start code 作为当前 NAL 的结束
            int nextStart = nalStart + 1;
            while (nextStart + 3 < len) {
                if (data[nextStart] == 0 && data[nextStart+1] == 0 && data[nextStart+2] == 0 && data[nextStart+3] == 1) break;
                nextStart++;
            }
            if (nextStart + 3 >= len) nextStart = len;
            int nalLen = nextStart - nalStart;
            LOGI("NAL type: %d, length: %d", nalType, nalLen);
            if (nalType == 7) { // SPS
                live->sps_len = nalLen;
                live->sps = static_cast<int8_t *>(malloc(nalLen));
                memcpy(live->sps, data + nalStart, nalLen);
                LOGI("SPS parsed, len=%d", nalLen);
            } else if (nalType == 8) { // PPS
                live->pps_len = nalLen;
                live->pps = static_cast<int8_t *>(malloc(nalLen));
                memcpy(live->pps, data + nalStart, nalLen);
                LOGI("PPS parsed, len=%d", nalLen);
                if (live->sps && live->pps) return 1;
            }
            offset = nextStart;
        } else {
            offset++;
        }
    }
    return (live->sps && live->pps) ? 1 : 0;
}

//视频帧packet
// MediaCodec 输出 Annex-B: [00 00 00 01][NAL header][NAL data]
// RTMP 需要 AVC 长度前缀: [帧类型][0x01][CT][NAL长度4字节][NAL数据]
RTMPPacket *createVideoPackage(int8_t *buf, int len, const long tms, Live *live) {
    LOGI("createVideoPackage: len=%d", len);
    // Annex-B: 前4字节是 00 00 00 01 start code,第5字节是 NAL header
    if (len < 5) return NULL;

    int nalType = buf[4] & 0x1F;
    int actualLen = len - 4; // 去掉 start code

    int body_size = 9 + actualLen;
    RTMPPacket *packet = (RTMPPacket *) malloc(sizeof(RTMPPacket));
    RTMPPacket_Alloc(packet, body_size);

    // 帧类型: 0x17=关键帧(IDR), 0x27=非关键帧
    packet->m_body[0] = 0x27;
    if (nalType == 5) {
        packet->m_body[0] = 0x17;
        LOGI("Sending IDR frame");
    }

    // AVCPacketType = 1 (NALU)
    packet->m_body[1] = 0x01;
    // CompositionTime
    packet->m_body[2] = 0x00;
    packet->m_body[3] = 0x00;
    packet->m_body[4] = 0x00;

    // NAL 长度 (4字节, AVC长度前缀)
    packet->m_body[5] = (actualLen >> 24) & 0xff;
    packet->m_body[6] = (actualLen >> 16) & 0xff;
    packet->m_body[7] = (actualLen >> 8) & 0xff;
    packet->m_body[8] = actualLen & 0xff;

    // NAL数据(去掉 Annex-B 的 00 00 00 01 start code)
    memcpy(&packet->m_body[9], buf + 4, actualLen);

    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 = live->rtmp->m_stream_id;
    return packet;
}

#endif //MEDIARECODER_PACKT_H

本 demo 在原始基础上做了以下修改,逐步解决了从闪退到推流失败的完整链路问题。

三、遇到的问题及解决方案

1. targetSdk 28 → 34 + 前台服务改造

文件 : build.gradle、AndroidManifest.xml、ScreenLive.java、MainActivity.java

问题:

  • targetSdk 28 在 Android 16 设备上弹"此应用与最新版 Android 不兼容"。

  • Android 14+(API 34) 要求 MediaProjection 录屏必须在前台服务 (mediaProjection 类型)中运行,否则 createVirtualDisplay 崩 IllegalStateException: Must register a callback before starting capture。

改动:

  • build.gradle: compileSdk/targetSdk 28 → 34。

  • AndroidManifest.xml: 加 FOREGROUND_SERVICE、FOREGROUND_SERVICE_MEDIA_PROJECTION、POST_NOTIFICATIONS 权限;注册 ScreenLive 为 foregroundServiceType="mediaProjection" 的 Service。

  • ScreenLive.java: 从 extends Thread 改成 extends Service。onStartCommand 里先 startForeground(API 34+ 传 FOREGROUND_SERVICE_TYPE_MEDIA_PROJECTION),再 getMediaProjection,再 registerCallback,最后 startWork。native 方法(connect/disConnect/sendData)、推流队列、工作线程保持不变。

  • MainActivity.java: 授权后 startForegroundService 而非直接启动线程。

影响: 消除"不兼容"提示;录屏在 Android 14+ 不再崩;符合 Android 14 前台服务要求。

2. abiFilters 加 arm64-v8a

文件 : build.gradle

问题 : 原来只编 armeabi-v7a,纯 64 位设备(只支持 arm64-v8a)加载不到 so。

改动 : abiFilters 'armeabi-v7a', 'arm64-v8a'。

影响 : 纯 64 位设备不再 libnative-lib.so not found。

3. MediaProjection registerCallback

文件 : ScreenLive.java

问题 : Android 14+ 要求 createVirtualDisplay 前必须 registerCallback,否则崩 Must register a callback before starting capture。

改动 : getMediaProjection 后 registerCallback(MediaProjection.Callback, Handler),onStop 里 stopLive。

影响 : createVirtualDisplay 不再崩。

4. H264 NAL 格式解析修复(Annex-B)

文件 : src/main/cpp/packt.h

问题:

  • prepareVideo: 原来按 AVCC 格式 (4 字节长度前缀)解析 SPS/PPS,但 MediaCodec H264 编码器实际输出 Annex-B 格式 (00 00 00 01 start code 分隔 NAL)。把 00 00 00 01 当成长度 1,导致 SPS 只取 1 字节、后续全乱、推流数据服务器无法解析。

  • createVideoPackage: 原来按 AVCC 读 4 字节长度(nalLength=1),还同时加了 AVC 长度前缀和 Annex-B 前缀(多余的 0x00000001),视频包格式错乱。

改动:

  • prepareVideo: 改成按 Annex-B 解析------找 00 00 00 01 start code 分割 NAL,正确提取 SPS/PPS。

  • createVideoPackage: actualLen = len - 4(去掉 Annex-B start code),转 RTMP AVC 长度前缀 格式([帧类型][0x01][CT 3字节][NAL长度 4字节][NAL数据]),不再加多余的 Annex-B 前缀。

影响: SPS/PPS 正确解析(18 字节而非 1 字节),视频帧格式正确,推流端能收到并显示画面。这是推流失败的核心修复。

5. 视频比特率提升

文件 : VideoCodec.java

问题: 原来比特率 500kbps 编 720x1280@20fps,画面质量低、推流端加载慢转圈。

改动 : KEY_BIT_RATE 500kbps → 1.2Mbps。

影响: 画面清晰度提升,推流端加载更快。

6. 启用音频推流

文件 : ScreenLive.java

问题: 原来音频编码(AudioCodec)被注释掉了,只推视频流,部分播放器等音频流才开始显示画面。

改动 : startWork 里加 audioCodec = new AudioCodec(ScreenLive.this); audioCodec.startLive();,停止时 audioCodec.stopLive()。

影响: 音视频同步推流,播放器能正常播放。

7. AudioCodec 缓冲区溢出修复

文件 : AudioCodec.java

问题 : AudioRecord.getMinBufferSize 返回 3584,但 AAC 编码器输入缓冲区默认只有 2048。inputBuffer.put(buffer, 0, len) 把 3584 字节放进 2048 缓冲区,BufferOverflowException 崩。

改动 : 把 minBufferSize 计算提前到格式创建之前,加 audioFormat.setInteger(MediaFormat.KEY_MAX_INPUT_SIZE, minBufferSize),让编码器分配足够大的输入缓冲区。

影响: 音频编码不再崩。


四、RTMP 源码架构设计

文件归属

文件 归属 说明
native-lib.cpp 本项目 JNI 桥接层,Java ↔ C 的接口
packt.h 本项目 RTMP 包构造(SPS/PPS 解析、视频/音频包组装)
CMakeLists.txt 本项目 顶层构建配置,链接 native-lib + rtmp
librtmp/* 开源库(已拷入项目) librtmp 完整源码
librtmp/CMakeLists.txt 本项目 librtmp 构建配置(-DNO_CRYPTO,编静态库)

librtmp 原始仓库:https://git.ffmpeg.org/gitweb/librtmp.git(本项目中 librtmp/ 是该仓库的源码拷贝,编译时关闭了加密 NO_CRYPTO,不依赖 OpenSSL。)

librtmp 模块划分


librtmp/

├── rtmp.c/h ← RTMP 协议核心:连接、握手、chunk 收发、命令

├── amf.c/h ← AMF0/AMF3 编解码

├── handshake.h ← RTMP 握手(C0/C1/C2/S0/S1/S2),#include 进 rtmp.c

├── parseurl.c ← RTMP URL 解析(rtmp://host:port/app/playpath)

├── log.c/h ← 日志系统

├── bytes.h ← 字节序工具(大小端读写)

├── rtmp_sys.h ← 系统头文件聚合(平台/编译器适配)

├── dh.h ← Diffie-Hellman 密钥交换(加密握手,NO_CRYPTO 时不编)

├── dhgroups.h ← DH 预定义群参数

├── http.h ← RTMPT(HTTP 隧道)支持

├── hashswf.c ← SWF 文件哈希验证

└── COPYING ← LGPL 许可证

核心数据结构

RTMP 结构体 (rtmp.h)------ 整个库的核心上下文:

typedef struct RTMP {

int m_inChunkSize; // 入 chunk 大小(默认 128)

int m_outChunkSize; // 出 chunk 大小

int m_stream_id; // createStream 返回的流 ID

RTMPPacket *m_vecChannelsInRTMP_CHANNELS; // 各 channel 入缓冲

RTMPPacket *m_vecChannelsOutRTMP_CHANNELS; // 各 channel 出缓冲

int m_channelTimestampRTMP_CHANNELS; // 各 channel 时间戳

double m_fAudioCodecs; // 音频编码能力

double m_fVideoCodecs; // 视频编码能力

double m_fEncoding; // AMF0 或 AMF3

RTMP_READ m_read; // 读取状态

RTMPPacket m_write; // 写入缓冲

RTMPSockBuf m_sb; // socket 缓冲

RTMP_LNK Link; // 连接参数(host/port/app/playpath/tcUrl/timeout...)

} RTMP;

RTMPPacket (rtmp.h)------ 一条 RTMP 消息:

typedef struct RTMPPacket {

uint8_t m_headerType; // chunk header 类型 (0=Large/1=Medium/2=Small/3=Minimum)

uint8_t m_packetType; // 消息类型 (0x08=Audio/0x09=Video/0x14=Command...)

uint8_t m_hasAbsTimestamp;

int m_nChannel; // chunk stream ID

uint32_t m_nTimeStamp; // 时间戳

int32_t m_nInfoField2; // 长 header 的 stream ID

uint32_t m_nBodySize; // body 大小

char *m_body; // body 数据

} RTMPPacket;

RTMPSockBuf (rtmp.h)------ socket 缓冲:

typedef struct RTMPSockBuf {

int sb_socket; // socket fd

int sb_size; // 未处理字节数

char *sb_start; // 下一个待处理字节

char sb_buf16\*1024; // socket 读取缓冲

int sb_timedout;

void *sb_ssl; // SSL 句柄(NO_CRYPTO 时为空)

} RTMPSockBuf;

连接生命周期(推流端)

cpp 复制代码
RTMP_SetupURL  ── 解析 URL(parseurl.c)
      │           rtmp://host:port/app/playpath → protocol/host/port/app/playpath
      ↓
RTMP_EnableWrite ── 设置 RTMP_FEATURE_WRITE 标志(推流模式,非播放)
      ↓
RTMP_Connect ──── TCP 三次握手
      │             RTMP_Connect0: socket connect
      │             RTMP_Connect1: HandShake + SendConnectPacket
      │
      ├─ HandShake (handshake.h)
      │    C0(1字节版本) → C1(1536字节时间戳+随机) → 等 S0+S1 → C2(回显S1)
      │    (本 demo 关了加密,是简单握手;开了 CRYPTO 才走 DH 复杂握手)
      │
      └─ SendConnectPacket
           AMF 编码 connect 命令(app/tcUrl/flashVer/audioCodecs/videoCodecs...)
           → 服务器回 _result → 连接建立
      ↓
RTMP_ConnectStream ── 创建流 + 发布
      │   循环 RTMP_ReadPacket 等待服务器响应
      │   RTMP_ClientPacket 处理命令:
      │     SendServerBW(带宽协商)
      │     SendCreateStream → 服务器回 _result(stream_id)
      │     SendPublish(releaseStream → FCPublish → publish)
      ↓
连接就绪,可以 RTMP_SendPacket 推音视频数据
      ↓
RTMP_Close ── 关闭 socket + 释放资源

RTMP协议整体结构图

写代码的时候需要根据协议来写代码。前面代码看不懂的照着这个来看

Message 怎么变成 Chunk

RTMP 传输层是 chunk 流,一个 RTMP 消息会被拆成多个 chunk:

这是 RTMP 协议最核心的一步。demo 在 packt.h 构造好一条 Message(RTMPPacket),然后 RTMP_SendPacket(librtmp rtmp.c)负责把 Message 拆成 Chunk 发到 TCP 上。

第一步:构造 Message (demo 代码 packt.h)

cpp 复制代码
// packt.h --- 构造一条视频 Message,body 是 NAL 数据
RTMPPacket *packet = (RTMPPacket *) malloc(sizeof(RTMPPacket));
RTMPPacket_Alloc(packet, body_size);  // 分配 body 内存

packet->m_body[0] = 0x17;             // 帧类型: 关键帧
packet->m_nBodySize = body_size;      // body 大小
packet->m_nChannel = 0x04;            // Chunk Stream ID(视频用 0x04)
packet->m_nTimeStamp = tms;           // 时间戳(毫秒)
packet->m_packetType = RTMP_PACKET_TYPE_VIDEO;  // 消息类型 0x09
packet->m_headerType = RTMP_PACKET_SIZE_LARGE;  // chunk header 类型: Large
packet->m_nInfoField2 = live->rtmp->m_stream_id; // Stream ID

这个时候 packet 是一条完整的 Message,body 里有几百到几千字节的 NAL 数据,还没拆。

第二步:拆成 Chunk 发出去 (librtmp 代码 rtmp.c:3176)

先看协议规定的 Chunk 结构(对照上面的图):

复制代码
一个 Chunk =
  ┌── Chunk Header (1~18 字节) ──────────────────────┐
  │                                                   │
  │  ① Basic Header (1~3 字节)                        │
  │     fmt    (2 bits)   --- Message Header 的格式类型   │
  │     csid  (6/14/22 bits) --- Chunk Stream ID         │
  │                                                   │
  │  ② Message Header (0/3/7/11 字节,取决于 fmt)       │
  │     fmt=0: Timestamp(3) + MsgLength(3) + TypeID(1) + StreamID(4) = 11字节 │
  │     fmt=1: TimestampΔ(3) + MsgLength(3) + TypeID(1)                  = 7字节 │
  │     fmt=2: TimestampΔ(3)                                             = 3字节 │
  │     fmt=3: 无                                                         = 0字节 │
  │                                                   │
  │  ③ Extended Timestamp (0 或 4 字节)               │
  │     仅当 Timestamp 字段 = 0xFFFFFF 时存在          │
  │                                                   │
  ├── Chunk Data (0~128 字节) ────────────────────────┤
  │  Message body 的一小片(≤ chunkSize,默认 128)     │
  └───────────────────────────────────────────────────┘

代码怎么拼这个结构:

cpp 复制代码
// rtmp.c --- RTMP_SendPacket:拼 Chunk Header + 切 body 发 TCP

// ① Basic Header (1字节): fmt(高2位) + csid(低6位)
//    packet->m_headerType=0(fmt=0), m_nChannel=4(csid=4)
//    0x00 << 6 | 0x04 = 0x04 → 一个字节: 00000100
c = packet->m_headerType << 6;          // fmt=0 左移6位到高2位
c |= packet->m_nChannel;                // 低6位放 csid=4
*hptr++ = c;                             // ← Basic Header 写入 (1字节)

// ② Message Header (fmt=0, 11字节):
//    Timestamp(3字节) + MessageLength(3字节) + TypeID(1字节) + StreamID(4字节)

//    Timestamp --- 3 字节,当 ≥ 0xFFFFFF 时写 0xFFFFFF 占位
hptr = AMF_EncodeInt24(hptr, hend, t > 0xffffff ? 0xffffff : t);  // ← Timestamp (3字节)

//    Message Length --- 3 字节,body 大小
hptr = AMF_EncodeInt24(hptr, hend, packet->m_nBodySize);  // ← Message Length (3字节)

//    Message Type ID --- 1 字节,0x09=视频 0x08=音频 0x14=命令
*hptr++ = packet->m_packetType;                            // ← Type ID (1字节)

//    Message Stream ID --- 4 字节,小端序
hptr += EncodeInt32LE(hptr, packet->m_nInfoField2);        // ← Stream ID (4字节)

// ③ Extended Timestamp (4字节,仅当 timestamp ≥ 0xFFFFFF 时写)
if (t >= 0xffffff)
    hptr = AMF_EncodeInt32(hptr, hend, t);  // ← Extended Timestamp (4字节)

// 到这里 Chunk Header 拼完了,共 1(Basic) + 11(Message) + 0或4(ExtTS) = 12 或 16 字节

然后切 body 发 TCP:

// ④ 按 chunkSize 切分 body,一片一片写到 TCP
nChunkSize = r->m_outChunkSize;  // 默认 128 字节
while (nSize > 0) {
    if (nSize < nChunkSize) nChunkSize = nSize;  // 最后一片可能不够 128
    WriteN(r, header, nChunkSize + hSize);       // 写 TCP: [Chunk Header] + [这片 body]
    nSize -= nChunkSize;
    buffer += nChunkSize;
    hSize = 0;  // 第一片发完后,后面片的 header 要重设

    // ⑤ 后续 Chunk: fmt=3, Message Header 为空,只有 Basic Header (1字节)
    if (nSize > 0) {
        header = buffer - 1;
        *header = 0xC0 | c;  // 0xC0 = fmt=3(11<<6), | csid → 只有 Basic Header, 无 Message Header
        hSize = 1;
    }
}

拆完长这样(假设 body 300 字节,chunkSize=128,fmt=0):

复制代码
TCP 上实际发送的字节流:

Chunk 1: [Basic Header 1B][Timestamp 3B][MsgLength 3B][TypeID 1B][StreamID 4B][body 0~127]
          └── Basic ──┘└──────────── Message Header (fmt=0, 11B) ──────────┘  └── Data ──┘
          └──────────── Chunk Header 12字节 ─────────────────────────────┘  └─ 128字节 ─┘

Chunk 2: [Basic Header 1B][body 128~255]
          └─ fmt=3 ─┘  └─ 128字节 ─┘
          (无 Message Header,沿用 Chunk 1 的信息)

Chunk 3: [Basic Header 1B][body 256~299]
          └─ fmt=3 ─┘  └─ 44字节 ─┘
          (最后一片,不到 128)

为什么要拆 Chunk:TCP 是流式传输,一次发一个大 Message 如果网络中断了整条消息都丢。拆成 128 字节的小 Chunk,丢了只要重传那个小 Chunk,而且多个 Message 的 Chunk 可以交叉发(音视频复用),不用等一个大 Message 发完。

其他层简述

应用层 --- 命令消息(AMF 编码)

connect/publish 等命令通过 AMF 编码,demo 通过 connect() 触发:

复制代码
// native-lib.cpp --- 调 librtmp 发 connect 命令
ret = RTMP_Connect(live->rtmp, 0);        // 内部: HandShake + SendConnectPacket(AMF 编码)
ret = RTMP_ConnectStream(live->rtmp, 0);   // 内部: SendCreateStream + SendPublish

RTMP 层 --- Handshake(握手)

复制代码
C0 (1字节: 版本号) → C1 (1536字节: 时间戳+随机数) → 等 S0+S1 → C2 (回显 S1)
本 demo 关了加密(NO_CRYPTO),走简单握手

传输层 --- TCP(socket)

复制代码
// native-lib.cpp --- 设置超时
live->rtmp->Link.timeout = 10;  // 连接超时 10s

// rtmp.c --- TCP 连接(librtmp 代码)
connect(r->m_sb.sb_socket, service, sizeof(struct sockaddr));  // TCP 三次握手
setsockopt(r->m_sb.sb_socket, IPPROTO_TCP, TCP_NODELAY, &on, sizeof(on));  // 关 Nagle 降延迟

AMF 编解码

amf.c/h 负责 AMF0/AMF3 的序列化/反序列化,用于 Command 消息:

// AMF0 类型

AMF_NUMBER = 0, // double (8字节)

AMF_BOOLEAN = 1, // bool (1字节)

AMF_STRING = 2, // AVal (长度+字符串)

AMF_OBJECT = 3, // key-value 对

AMF_NULL = 5,

AMF_ECMA_ARRAY = 8, // 关联数组

...

// 编码函数

AMF_EncodeString(buf, end, &str); // type=22字节长度字符串

AMF_EncodeNumber(buf, end, 3.14); // type=08字节double

AMF_EncodeInt24(buf, end, 12345); // 3字节大端序

// connect 命令的 AMF 编码示例:

// "connect" + { app:"live", tcUrl:"rtmp://...", flashVer:"...", audioCodecs:..., videoCodecs:... }

AVal 是 librtmp 的字符串类型({char *av_val, int av_len}),不是 C 字符串(不依赖 \0 结尾)。

发送音视频数据

本项目通过 RTMP_SendPacket(r, packet, 1) 发送:

packt.h 构造 RTMPPacket

│

├─ createSpsPpsPackage: 0x170x00CTAVC sequence header: SPS+PPS

├─ createVideoPackage: 0x17/0x270x01CTNAL长度4字节NAL数据

└─ createAudioPackage: 0xAF0x00/0x01AAC数据

│

↓

RTMP_SendPacket (rtmp.c)

├─ 压缩 chunk header(和前一包比较)

├─ 按 chunkSize 切分 body

├─ 写 chunk header + data

└─ RTMPSockBuf_Send → write(socket)

构建

AGP 7.0.3 / Gradle 7.2,需 JDK 11(JDK 8 会报 "requires Java 11")。

先build再run

五、抗弱网能力

现有自带的弱网相关机制

RTMP 跑在 TCP 上,协议本身和 librtmp 库不提供应用层抗弱网能力,但 demo 里已有几个基础机制:

机制 代码位置 作用 弱网效果
checkDrop() ScreenLive.java:169 队列 > 200 丢旧包 防止推不动时内存堆积、延迟越来越大,但丢了就是丢了,播放端会卡顿花屏
TCP_NODELAY librtmp/rtmp.c 关闭 Nagle 算法 小包立即发,降低延迟,但弱网下不减少丢包
Link.timeout = 10 native-lib.cpp:26 连接超时 10s 连不上快速失败,不卡死
每 2s 强制关键帧 VideoCodec.java:76 PARAMETER_KEY_REQUEST_SYNC_FRAME 弱网丢包导致花屏后,关键帧能快速恢复画面
TCP 可靠传输 OS 内核 TCP 自带重传和拥塞控制 保证数据不丢,但弱网时重传导致延迟累积、越推越卡

RTMP 协议层面的弱网局限

RTMP 跑在 TCP 上,TCP 的可靠传输在流媒体场景反而是负担:

  • 队头阻塞:一个包丢了,后面的包全等着重传,延迟雪崩

  • 拥塞控制不感知媒体:TCP 按字节流控,不管丢的是关键帧还是 P 帧,关键帧丢了和 P 帧丢了同样重传

  • 没有 FEC/冗余:协议本身不提供前向纠错

弱网下的表现:延迟越推越大 → 画面卡顿花屏 → 严重时直接断连。

后续演进的业务抗弱网能力

如果后续需要在业务层增强抗弱网,可以分三档:

第一档:在现有架构上加(改动小)

1. 动态码率:VideoCodec 编码循环里,根据网络状况调码率、帧率、分辨率

java 复制代码
// 网络差时降码率 
Bundle params = new Bundle(); 
params.putInt(MediaCodec.PARAMETER_KEY_VIDEO_BITRATE, newBitrate); // 1.2M → 500k 
mMediaCodec.setParameters(params);

判断网络差的信号:

  • RTMP_SendPacket 返回 false / 超时 → 网络差

  • 队列堆积(mRTMPPackageLinkedBlockingQueue.size() 持续增长)→ 推不动

  • 编码到发送的间隔越来越大 → 延迟累积

2. 重连机制 :sendData 返回 false 时不直接停,断开重连(disConnect → sleep → connect),最大重试 N 次才真正停。

3. 按帧类型丢帧:弱网时丢 P 帧、保关键帧(P 帧丢了不影响解码恢复,I 帧丢了花屏),按时间戳丢旧包(超过 2s 的包直接丢,不让延迟堆积)。

第二档:换传输层(改动中)

RTMP over TCP 的队头阻塞是根本问题,换协议能从根上改善:

协议 传输层 弱网优势 改动量
SRT UDP ARQ 重传 + 带宽预测 + 不队头阻塞 换 librtmp → libsrt,编码层不变
WebRTC UDP + RTP GCC 拥塞控制 + NACK/FEC + 动态码率 架构重写,但抗弱网最强
RIST UDP ARQ + 多路径 类似 SRT

换 SRT 性价比最高:编码层(MediaCodec)完全不动,只把 native-lib.cpp 里的 librtmp 调用换成 libsrt,推流地址从 rtmp:// 改成 srt://,服务器端换成支持 SRT 的(如 SRS 5.0+)。

第三档:完善的弱网方案(改动大)

直播平台级别的抗弱网需要:

  1. 网络质量实时监测:独立线程测 RTT、丢包率、可用带宽

  2. 动态码率 + 动态分辨率 + 动态帧率三者联动,根据带宽分级降级

  3. 双流策略:同时推高清 + 低清两条流,播放端按网络选

  4. 编码端 SEI 增强:关键帧前插 SEI(补充增强信息),帮播放端更快恢复

  5. 服务端转码 + 码率自适应:HLS/DASH 多档位,CDN 层做


六、流媒体协议体系

流媒体格式

流媒体格式的核心特征:收到一帧就能播一帧,中途断了不影响已播放的内容,不需要等整个文件传完才能开始播放。和"传文件"的区别就在这里------MP4 文件头部(moov box)没写完播放器打不开,流媒体每帧独立可播。分两层:

编码层(压缩原始音视频):

  • H.264/H.265(视频)、AAC/Opus(音频)------压缩后的裸码流(NAL/AAC 帧)

封装层(给裸码流加时间戳、分轨、打包成可传输的单元):

  • FLV :RTMP 传输用的封装格式,Tag = 音频Tag/视频Tag/脚本Tag,每个 Tag 带时间戳。本 demo 的 packt.h 构造的就是 FLV Tag 格式。

  • MP4:文件存储用,moov/mdat box 结构,不适合实时流(头部要写完才能播)

  • TS:HLS 用的,188 字节固定包,适合分片传输但开销大

  • WebM/MKV:WebRTC/VP8/VP9 用的

关系:编码(H264/AAC) → 封装(FLV/MP4/TS) → 传输协议(RTMP/HLS/WebRTC)


RTMP 是流媒体协议而非通用传输协议,判断依据是它为音视频的连续、实时传输做了专门设计。以下从这个 demo 的代码出发,看哪些方面体现了流媒体协议的特征。

1. 设计目标:实时传输音视频

RTMP 全称 Real-Time Messaging Protocol,设计初衷是低延迟传输音视频流,不是传文件/网页。这个 demo 的整个链路------MediaProjection 录屏 → MediaCodec 编码 → librtmp 推流------就是为实时音视频传输服务的。

2. 流复用 + 独立通道

一条 TCP 连接上可复用多个 Stream,每个 Stream 有独立的 Stream ID,分别承载音频流、视频流、数据流(弹幕、元数据、控制命令)。

代码体现:

  • RTMP 结构体的 m_stream_id(rtmp.h):createStream 返回的流 ID

  • RTMPPacket.m_nInfoField2(rtmp.h):长 header 里的 stream ID,标识这条消息属于哪个流

  • 本 demo 用同一条连接推音视频两条流,通过 m_packetType(0x08=Audio / 0x09=Video)区分

3. 消息分块(Chunk)+ 时间戳

RTMP 把消息拆成 Chunk 传输,每个 Chunk 带时间戳------这是流媒体协议的典型特征,让接收端能按时间顺序还原音视频、做同步和播放控制。传文件的协议不需要每块都带时间戳。

代码体现:

  • RTMPPacket.m_nTimeStamp(rtmp.h):每条消息的时间戳,本 demo 在 packt.h 构造包时设置(packet->m_nTimeStamp = tms),tms 来自 MediaCodec.BufferInfo.presentationTimeUs

  • Chunk header 的 fmt 0~3 压缩机制(见"二、RTMP 源码架构设计 > Chunk 协议"):时间戳不变时用 fmt 2/3 压缩 header,减少开销

4. 会话控制命令集

RTMP 定义了一套 AMF 编码的命令消息,专门用于流媒体会话管理,普通传输协议没有这套语义:

命令 作用 本 demo 调用
connect 建立应用连接 RTMP_Connect → SendConnectPacket
createStream 创建流 RTMP_ConnectStream → SendCreateStream
publish 开始推流 RTMP_ConnectStream → SendPublish
play 开始播放 本 demo 是推流端,不调 play
deleteStream 删除流 RTMP_Close
pause / seek 暂停/拖动 本 demo 不涉及

这些命令通过 amf.c 的 AMF_EncodeString/AMF_EncodeNumber 序列化,是"直播会话"量身定制的语义。

5. 封装流媒体格式(FLV Tag)

RTMP 传输的音视频按 FLV Tag 格式封装,传的是"一帧一帧、按时间排列的媒体数据",不是完整文件:

代码体现(packt.h):

  • createSpsPpsPackage:FLV Video Tag 的 AVC sequence header([0x17][0x00][SPS+PPS])

  • createVideoPackage:FLV Video Tag 的 NALU([0x17/0x27][0x01][CT][NAL长度][NAL数据])

  • createAudioPackage:FLV Audio Tag([0xAF][0x00/0x01][AAC数据])

6. 推/拉两种模式

RTMP 支持 publish(推流)和 play(拉流)两种模式,正是直播的两种基本数据流向。本 demo 是推流端:

代码体现:

  • RTMP_EnableWrite(rtmp.c:263):设置 RTMP_FEATURE_WRITE 标志,告诉服务器"我是推流端"

  • 不调 play 命令,只调 publish

7. 完整的协议分层

RTMP 有明确的协议分层,大量机制为"持续、实时、有序传输媒体流"服务:

握手层(Handshake) C0/C1/C2、S0/S1/S2 ← handshake.h

块层(Chunk Stream) 分块、复用、时间戳压缩 ← rtmp.c: RTMP_SendPacket

消息层(Message) 协议控制/命令/数据/音视频消息 ← RTMPPacket.m_packetType

用户控制消息 StreamBegin/SetBufferLength ← rtmp.c: RTMP_SendCtrl

对比:为什么 HTTP 传文件不是流媒体协议

维度 RTMP HTTP(传文件)
传输对象 连续音视频帧 完整文件
时间戳 每块带 无
流复用 多 Stream 复用 无
会话命令 connect/publish/play/pause 无
延迟目标 实时(秒级内) 不关心
推拉模式 支持推+拉 只有拉

为什么拉流一般不用 RTMP

RTMP 推流仍然主流(编码器、OBS 都支持),但拉流播放端基本都换掉了,原因:

  1. HTTP-RTMP 被浏览器淘汰:RTMP 依赖 Flash Player,2020 年后浏览器全面移除 Flash,网页端无法直接播 RTMP 流。现在拉流走 HTTP-based 协议(HLS/DASH/LL-HLS),浏览器原生支持。

  2. HLS/DASH 兼容性碾压:HLS 基于 HTTP,任何能播视频的端(浏览器、手机、智能电视)都原生支持,不需要额外 SDK。RTMP 拉流需要专门的播放器或 SDK(如 librtmp、ExoPlayer 扩展)。

  3. CDN 分发成本:RTMP 是长连接,CDN 要维护每个观众的 TCP 长连接,并发成本高。HLS 是 HTTP 短连接切片文件,CDN 直接缓存分发,成本低得多。

  4. 防火墙穿透:RTMP 走 TCP 1935 端口,很多公司/学校防火墙封非 80/443 端口。HLS 走 HTTP 80/443,到处都能过。

  5. 延迟 tradeoff:HLS 延迟 5-30s(分片+HTTP),但普通直播能接受。RTMP 延迟 1-3s 但前面那些问题没法解决。低延迟直播现在走 LL-HLS(1-3s)或 WebRTC(<1s),不是 RTMP。

现在的格局:推流用 RTMP (编码器/SDK 成熟、低延迟),拉流用 HLS/DASH(兼容性好、CDN 友好),中间由服务器转协议(RTMP → HLS)。本 demo 只做了推流端,没涉及拉流。

相关推荐
疯华整猫12 分钟前
同一个 App,五种手机五种死法:2026 年 Android 五大 ROM 兼容的 8 个真实坑
android·性能优化
疯华整猫32 分钟前
别再抄 Flutter 了:2026 年 Android / iOS / 小程序跨端架构选型的四本成本账
android·前端·ios
传奇开心果编程1 小时前
【Flutter踩坑排雷】第30课:异常未捕获坑|未捕获异常直接闪退,全局兜底故障处理
android·flutter·ios·移动开发·dart·ui框架·声明式ui
恋猫de小郭2 小时前
Flutter Native Interop 稳定了,Platform Channel 要退场了
android·前端·flutter
好的佩奇13 小时前
Dart 之可迭代对象与生成器
android·flutter·dart
_祝你今天愉快13 小时前
Paint Cavans高级绘制:[三] Canvas高阶使用技巧-变换,状态保存,离屏缓冲,粒子特效
android
小乖写代码13 小时前
提交注册验证 · WhatsApp /v2/register
android·网络·账号注册
二流小码农18 小时前
鸿蒙开发:router组件升级,彻底告别手动配置
android·ios·harmonyos
Digitally18 小时前
如何在安卓设备上使用 4 种简单方法将应用移动到 SD 卡
android