Android RTMP 录屏直播推流:MediaProjection 录屏 + MediaCodec 硬编 H264/AAC + librtmp 推流。
老样子,先源码、效果图,再详解
源码地址
效果图
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 模块划分)
[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/targetSdk28 → 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 01start code 分隔 NAL)。把00 00 00 01当成长度 1,导致 SPS 只取 1 字节、后续全乱、推流数据服务器无法解析。 -
createVideoPackage: 原来按 AVCC 读 4 字节长度(nalLength=1),还同时加了 AVC 长度前缀和 Annex-B 前缀(多余的0x00000001),视频包格式错乱。
改动:
-
prepareVideo: 改成按 Annex-B 解析------找00 00 00 01start 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+)。
第三档:完善的弱网方案(改动大)
直播平台级别的抗弱网需要:
-
网络质量实时监测:独立线程测 RTT、丢包率、可用带宽
-
动态码率 + 动态分辨率 + 动态帧率三者联动,根据带宽分级降级
-
双流策略:同时推高清 + 低清两条流,播放端按网络选
-
编码端 SEI 增强:关键帧前插 SEI(补充增强信息),帮播放端更快恢复
-
服务端转码 + 码率自适应: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 都支持),但拉流播放端基本都换掉了,原因:
-
HTTP-RTMP 被浏览器淘汰:RTMP 依赖 Flash Player,2020 年后浏览器全面移除 Flash,网页端无法直接播 RTMP 流。现在拉流走 HTTP-based 协议(HLS/DASH/LL-HLS),浏览器原生支持。
-
HLS/DASH 兼容性碾压:HLS 基于 HTTP,任何能播视频的端(浏览器、手机、智能电视)都原生支持,不需要额外 SDK。RTMP 拉流需要专门的播放器或 SDK(如 librtmp、ExoPlayer 扩展)。
-
CDN 分发成本:RTMP 是长连接,CDN 要维护每个观众的 TCP 长连接,并发成本高。HLS 是 HTTP 短连接切片文件,CDN 直接缓存分发,成本低得多。
-
防火墙穿透:RTMP 走 TCP 1935 端口,很多公司/学校防火墙封非 80/443 端口。HLS 走 HTTP 80/443,到处都能过。
-
延迟 tradeoff:HLS 延迟 5-30s(分片+HTTP),但普通直播能接受。RTMP 延迟 1-3s 但前面那些问题没法解决。低延迟直播现在走 LL-HLS(1-3s)或 WebRTC(<1s),不是 RTMP。
现在的格局:推流用 RTMP (编码器/SDK 成熟、低延迟),拉流用 HLS/DASH(兼容性好、CDN 友好),中间由服务器转协议(RTMP → HLS)。本 demo 只做了推流端,没涉及拉流。