树莓派（Python+OpenCV）向Jetpack Compose安卓应用推流的低延迟优化及视频控制方案咨询

我太懂你现在的困扰了——用MJPEG+WebView虽然能快速跑通，但延迟不算低，而且WebView对视频尺寸、对齐的控制完全被HTML和WebView自身的渲染逻辑绑住，想调个完美的布局真的头疼。下面给你几个更贴合需求的方案，既能压低延迟，又能在Jetpack Compose里完全掌控视频的显示效果：

方案一：改用RTSP/RTMP推流 + Jetpack Compose集成ExoPlayer（平衡低延迟与开发效率） #

这个方案是目前最推荐的，RTSP/RTMP的延迟比MJPEG低很多（能压到几百毫秒甚至更低），而且ExoPlayer是安卓官方的媒体播放库，有专门的Jetpack Compose组件，视频的尺寸、对齐、缩放模式全由你说了算。

树莓派端修改（推RTSP流） #

你可以在现有OpenCV代码的基础上，用FFmpeg把编码后的帧推到一个轻量RTSP服务器（比如rtsp-simple-server，直接在树莓派上部署就行），代码示例如下：

import cv2
import subprocess

cap = cv2.VideoCapture(0)
# 设置摄像头分辨率，降低分辨率能进一步降低延迟
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)

# FFmpeg命令：把OpenCV的帧推到本地RTSP服务器
ffmpeg_cmd = [
    'ffmpeg',
    '-y',
    '-f', 'rawvideo',
    '-vcodec', 'rawvideo',
    '-pix_fmt', 'bgr24',
    '-s', '640x480',
    '-r', '25',  # 帧率
    '-i', '-',
    '-c:v', 'libx264',
    '-preset', 'ultrafast',  # 超快编码，优先降低延迟
    '-tune', 'zerolatency',
    '-f', 'rtsp',
    'rtsp://your-raspberry-pi-ip:8554/stream'
]

process = subprocess.Popen(ffmpeg_cmd, stdin=subprocess.PIPE)

while True:
    success, frame = cap.read()
    if not success:
        break
    # 把帧写入FFmpeg的标准输入
    process.stdin.write(frame.tobytes())

cap.release()
process.stdin.close()
process.wait()

先在树莓派上安装rtsp-simple-server（直接从GitHub下载二进制包启动即可），就能接收推流了。

安卓Jetpack Compose端实现 #

用ExoPlayer的Compose扩展库，你可以完全通过Modifier控制视频的尺寸、对齐，还能设置缩放模式：

// 先在build.gradle添加依赖
// implementation "androidx.media3:media3-exoplayer:1.1.1"
// implementation "androidx.media3:media3-exoplayer-rtsp:1.1.1"
// implementation "androidx.media3:media3-ui:1.1.1"

@Composable
fun RtspVideoPlayer(
    rtspUrl: String,
    modifier: Modifier = Modifier
) {
    val context = LocalContext.current
    val exoPlayer = remember {
        ExoPlayer.Builder(context)
            .build()
            .apply {
                val mediaItem = MediaItem.fromUri(rtspUrl)
                setMediaItem(mediaItem)
                prepare()
                play()
            }
    }

    DisposableEffect(Unit) {
        onDispose {
            exoPlayer.release()
        }
    }

    // 用Media3的Compose组件，完全自定义布局
    PlayerView(
        player = exoPlayer,
        modifier = modifier
            .fillMaxWidth()
            .aspectRatio(16f/9f) // 自定义宽高比
            .align(Alignment.Center), // 对齐方式
        controllerAutoShow = false // 隐藏默认控制器，可自行实现UI
    )
}

// 使用示例
@Composable
fun VideoScreen() {
    Box(modifier = Modifier.fillMaxSize()) {
        RtspVideoPlayer(
            rtspUrl = "rtsp://your-raspberry-pi-ip:8554/stream",
            modifier = Modifier.fillMaxSize()
        )
    }
}

方案二：自定义UDP/TCP裸流传输（极致低延迟，适合对延迟要求极高的场景） #

如果需要几十毫秒级的超低延迟，直接自己实现帧的传输和解码是最优解。树莓派端把OpenCV的帧编码成H.264裸流，通过UDP发送，安卓端用MediaCodec硬解码，然后在Jetpack Compose的Canvas或者Image组件里渲染。

树莓派端代码示例（UDP发送H.264帧） #

import cv2
import socket

cap = cv2.VideoCapture(0)
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)
cap.set(cv2.CAP_PROP_FPS, 30)

# 初始化UDP socket
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
server_address = ('your-android-ip', 5000)

while True:
    success, frame = cap.read()
    if not success:
        break
    # 编码成H.264（调整QP值控制画质与延迟）
    ret, buffer = cv2.imencode('.h264', frame, [cv2.IMWRITE_H264_QP, 20])
    if ret:
        # 发送帧数据（注意UDP包大小限制，大帧需要分割）
        sock.sendto(buffer.tobytes(), server_address)

cap.release()
sock.close()

安卓端解码与渲染（Jetpack Compose） #

安卓端需要用MediaCodec接收UDP数据，解码成YUV帧后转换成Bitmap，再用Compose的Image组件显示，简化示例如下：

@Composable
fun UdpVideoPlayer(modifier: Modifier = Modifier) {
    val context = LocalContext.current
    val bitmapState = remember { mutableStateOf<Bitmap?>(null) }

    LaunchedEffect(Unit) {
        val udpSocket = DatagramSocket(5000)
        val buffer = ByteArray(1024*1024)
        val packet = DatagramPacket(buffer, buffer.size)
        
        // 初始化MediaCodec解码H.264
        val codec = MediaCodec.createDecoderByType("video/avc")
        val format = MediaFormat.createVideoFormat("video/avc", 640, 480)
        codec.configure(format, null, null, 0)
        codec.start()

        while (true) {
            udpSocket.receive(packet)
            val data = packet.data.copyOfRange(0, packet.length)
            
            // 把数据送入MediaCodec解码
            val inputBufferIndex = codec.dequeueInputBuffer(1000)
            if (inputBufferIndex >= 0) {
                val inputBuffer = codec.getInputBuffer(inputBufferIndex)
                inputBuffer?.put(data)
                codec.queueInputBuffer(inputBufferIndex, 0, data.size, System.nanoTime()/1000, 0)
            }

            // 获取解码后的帧并转换为Bitmap
            val bufferInfo = MediaCodec.BufferInfo()
            val outputBufferIndex = codec.dequeueOutputBuffer(bufferInfo, 1000)
            if (outputBufferIndex >= 0) {
                val outputBuffer = codec.getOutputBuffer(outputBufferIndex)
                // 这里需要实现YUV转Bitmap的工具方法
                val bitmap = YuvToBitmap.convert(outputBuffer, bufferInfo, 640, 480)
                bitmapState.value = bitmap
                codec.releaseOutputBuffer(outputBufferIndex, true)
            }
        }
    }

    bitmapState.value?.let { bitmap ->
        Image(
            bitmap = bitmap.asImageBitmap(),
            contentDescription = "Streamed video",
            modifier = modifier
                .fillMaxSize()
                .align(Alignment.Center),
            contentScale = ContentScale.Fit // 自定义缩放模式
        )
    }
}

这个方案延迟极低，但需要自己处理帧分割、解码同步等细节，适合有一定安卓多媒体开发经验的场景。

为什么放弃MJPEG+WebView？ #

• 延迟高：MJPEG是逐帧发送JPEG图片，每帧都要编码和解码，延迟通常在1-2秒左右，远不如RTSP/RTMP或裸流。
• 布局受限：WebView的视频布局受HTML/CSS限制，很难和Jetpack Compose的原生布局系统完美融合，尺寸和对齐的控制非常生硬。

内容来源于stack exchange