1.修改文件推流

Dana

2025-12-02 8bc72ebc21e04e3d52f7250716c44d3104bfecfa

1.修改文件推流

 app/src/main/java/com/anyun/h264/H264FileTransmitter.java

@@ -55,6 +55,10 @@
    private int frameRate = 25; // 帧率，用于计算时间戳间隔
    private long frameInterval = 1000 / 25; // 帧间隔（毫秒）
    
    // SPS/PPS缓存
    private byte[] spsBuffer;
    private byte[] ppsBuffer;
    
    // 时间戳管理
    private long lastIFrameTime = 0; // 上一个I帧时间
    private long lastFrameTime = 0; // 上一帧时间
@@ -151,6 +155,8 @@
        baseTimestamp = System.currentTimeMillis();
        lastIFrameTime = 0;
        lastFrameTime = 0;
        spsBuffer = null;
        ppsBuffer = null;
        
        Timber.d("Socket initialized successfully");
        return true;
@@ -427,36 +433,7 @@
            int dataType = isKeyFrame ? JT1076ProtocolHelper.DATA_TYPE_I_FRAME :
                    JT1076ProtocolHelper.DATA_TYPE_P_FRAME;
            
            // 分包发送（如果数据超过最大包大小）
            int offset = 0;
            int totalPackets = (int) Math.ceil((double) frameData.length / JT1076ProtocolHelper.MAX_PACKET_SIZE);
            
            for (int i = 0; i < totalPackets; i++) {
                int packetDataSize = Math.min(JT1076ProtocolHelper.MAX_PACKET_SIZE, frameData.length - offset);
                byte[] packetData = Arrays.copyOfRange(frameData, offset, offset + packetDataSize);
                
                // 确定分包标记
                int packetMark;
                if (totalPackets == 1) {
                    packetMark = JT1076ProtocolHelper.PACKET_MARK_ATOMIC;
                } else if (i == 0) {
                    packetMark = JT1076ProtocolHelper.PACKET_MARK_FIRST;
                } else if (i == totalPackets - 1) {
                    packetMark = JT1076ProtocolHelper.PACKET_MARK_LAST;
                } else {
                    packetMark = JT1076ProtocolHelper.PACKET_MARK_MIDDLE;
                }
                
                // 创建RTP包
                byte[] rtpPacket = protocolHelper.createVideoRtpPacket(
                        packetData, timestamp, dataType, packetMark,
                        lastIFrameInterval, lastFrameInterval);
                
                // 发送RTP包（UDP或TCP，根据协议类型自动选择）
                protocolHelper.sendPacket(rtpPacket);
                
                offset += packetDataSize;
            }
            processNalUnits(frameData, timestamp, lastIFrameInterval, lastFrameInterval);
            
            // 控制发送速率（模拟帧率）
            if (frameInterval > 0) {
@@ -498,10 +475,160 @@
            protocolHelper.closeSocket();
        }
        
        spsBuffer = null;
        ppsBuffer = null;
        
        Timber.d("H264 file transmitter stopped");
    }
    
    /**
     * 解析帧中的NAL单元并根据类型处理
     */
    private void processNalUnits(byte[] frameData, long timestamp,
                                 long lastIFrameInterval, long lastFrameInterval) {
        if (frameData == null || frameData.length == 0) {
            return;
        }
        
        boolean nalProcessed = false;
        int offset = 0;
        while (offset < frameData.length) {
            int startCodePos = findStartCode(frameData, offset);
            if (startCodePos < 0) {
                break;
            }
            
            int startCodeLen = getStartCodeLength(frameData, startCodePos);
            int nalDataStart = startCodePos + startCodeLen;
            if (nalDataStart >= frameData.length) {
                break;
            }
            
            int nextStart = findStartCode(frameData, nalDataStart);
            int nalEnd = (nextStart == -1) ? frameData.length : nextStart;
            int nalLength = nalEnd - startCodePos;
            if (nalLength <= startCodeLen) {
                break;
            }
            
            byte[] nalUnit = Arrays.copyOfRange(frameData, startCodePos, nalEnd);
            int nalType = nalUnit[startCodeLen] & 0x1F;
            
            handleNalUnit(nalUnit, nalType, timestamp, lastIFrameInterval, lastFrameInterval);
            nalProcessed = true;
            offset = nalEnd;
        }
        
        if (!nalProcessed) {
            // 没有解析出NAL单元时，直接按P帧发送
            sendFramePayload(frameData, timestamp, false, lastIFrameInterval, lastFrameInterval);
        }
    }
    
    private void handleNalUnit(byte[] nalUnit, int nalType, long timestamp,
                               long lastIFrameInterval, long lastFrameInterval) {
        switch (nalType) {
            case 7: // SPS
                spsBuffer = nalUnit.clone();
                Timber.d("Cached SPS, size: %d", spsBuffer.length);
                break;
            case 8: // PPS
                ppsBuffer = nalUnit.clone();
                Timber.d("Cached PPS, size: %d", ppsBuffer.length);
                break;
            case 5: // IDR
                if (spsBuffer != null && ppsBuffer != null) {
                    byte[] combined = combineFrameData(spsBuffer, ppsBuffer, nalUnit);
                    sendFramePayload(combined, timestamp, true, lastIFrameInterval, lastFrameInterval);
                } else {
                    Timber.w("IDR frame without SPS/PPS cache, sending raw IDR");
                    sendFramePayload(nalUnit, timestamp, true, lastIFrameInterval, lastFrameInterval);
                }
                break;
            case 1: // P frame
                sendFramePayload(nalUnit, timestamp, false, lastIFrameInterval, lastFrameInterval);
                break;
            default:
                Timber.d("Forwarding NAL type %d, size: %d", nalType, nalUnit.length);
                sendFramePayload(nalUnit, timestamp, false, lastIFrameInterval, lastFrameInterval);
                break;
        }
    }
    
    private void sendFramePayload(byte[] payload, long timestamp, boolean isKeyFrame,
                                  long lastIFrameInterval, long lastFrameInterval) {
        if (payload == null || payload.length == 0) {
            return;
        }
        
        int dataType = isKeyFrame ? JT1076ProtocolHelper.DATA_TYPE_I_FRAME :
                JT1076ProtocolHelper.DATA_TYPE_P_FRAME;
        
        int offset = 0;
        int totalPackets = (int) Math.ceil((double) payload.length / JT1076ProtocolHelper.MAX_PACKET_SIZE);
        for (int i = 0; i < totalPackets; i++) {
            int packetDataSize = Math.min(JT1076ProtocolHelper.MAX_PACKET_SIZE, payload.length - offset);
            byte[] packetData = Arrays.copyOfRange(payload, offset, offset + packetDataSize);
            
            int packetMark;
            if (totalPackets == 1) {
                packetMark = JT1076ProtocolHelper.PACKET_MARK_ATOMIC;
            } else if (i == 0) {
                packetMark = JT1076ProtocolHelper.PACKET_MARK_FIRST;
            } else if (i == totalPackets - 1) {
                packetMark = JT1076ProtocolHelper.PACKET_MARK_LAST;
            } else {
                packetMark = JT1076ProtocolHelper.PACKET_MARK_MIDDLE;
            }
            
            byte[] rtpPacket = protocolHelper.createVideoRtpPacket(
                    packetData, timestamp, dataType, packetMark,
                    lastIFrameInterval, lastFrameInterval);
            protocolHelper.sendPacket(rtpPacket);
            offset += packetDataSize;
        }
    }
    
    private int findStartCode(byte[] data, int startPos) {
        if (data == null || startPos >= data.length - 3) {
            return -1;
        }
        for (int i = startPos; i < data.length - 3; i++) {
            if (isStartCodeAt(data, i)) {
                return i;
            }
        }
        // 处理剩余不足4字节但可能是3字节起始码的情况
        for (int i = Math.max(startPos, data.length - 3); i < data.length - 2; i++) {
            if (isStartCodeAt(data, i)) {
                return i;
            }
        }
        return -1;
    }
    
    private byte[] combineFrameData(byte[] sps, byte[] pps, byte[] idr) {
        int totalLength = (sps != null ? sps.length : 0) +
                (pps != null ? pps.length : 0) +
                (idr != null ? idr.length : 0);
        byte[] combined = new byte[totalLength];
        int offset = 0;
        if (sps != null) {
            System.arraycopy(sps, 0, combined, offset, sps.length);
            offset += sps.length;
        }
        if (pps != null) {
            System.arraycopy(pps, 0, combined, offset, pps.length);
            offset += pps.length;
        }
        if (idr != null) {
            System.arraycopy(idr, 0, combined, offset, idr.length);
        }
        Timber.d("Combined SPS/PPS/IDR payload, total: %d", totalLength);
        return combined;
    }
    
    /**
     * 释放资源
     */
    public void release() {

 app/src/main/java/com/anyun/h264/JT1076ProtocolHelper.java

@@ -67,6 +67,7 @@
    public void setServerAddress(String ip, int port) {
        this.serverIp = ip;
        this.serverPort = port;
        Timber.w("设置IP="+ip+"_port:"+port);
        // 如果TCP客户端已存在，更新地址
        if (tcpClient != null) {
            tcpClient.setServerAddress(ip, port);

 app/src/main/java/com/anyun/h264/MainActivity.kt

@@ -1,7 +1,7 @@
package com.anyun.h264

import android.os.Bundle
import timber.log.Timber
import android.util.Log
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
@@ -12,25 +12,29 @@
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import com.anyun.h264.ui.theme.MyApplicationTheme
import timber.log.Timber
import java.io.File

class MainActivity : ComponentActivity() {
    private var h264Encoder: H264Encoder? = null
    
    private var transmitter: H264FileTransmitter? = null
    companion object{
        const val TAG ="MainActivity"
    }
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        

        setContent {
            var isRunning by remember { mutableStateOf(false) }
            

            MyApplicationTheme {
                Scaffold(modifier = Modifier.fillMaxSize()) { innerPadding ->
                    MainScreen(
                        modifier = Modifier.padding(innerPadding),
                        isRunning = isRunning,
                        onStartH264Click = {
                            val success = startH264Encoder()
                            val success = startFileTransmitter()
                            if (success) {
                                isRunning = true
                            }
@@ -44,40 +48,79 @@
            }
        }
    }
    

    override fun onDestroy() {
        super.onDestroy()
        stopH264Encoder()
    }
    

    private fun startFileTransmitter():Boolean {

        if (transmitter != null) {
            Timber.w("H264Encoder is already running")
            return false
        }



        try {
            transmitter = H264FileTransmitter()
            Log.i(TAG,"startFileTransmitter")
            transmitter?.setServerAddress("192.168.16.138", 1078)
            transmitter?.setProtocolType(JT1076ProtocolHelper.PROTOCOL_TYPE_TCP) // 或 PROTOCOL_TYPE_UDP


            // 设置协议参数
            transmitter?.setProtocolParams("013120122580", 1.toByte())


            // 设置帧率（用于计算时间戳间隔）
            transmitter?.setFrameRate(25)


            // 初始化Socket
            if (transmitter?.initialize()==true) {
                // 开始传输文件
                transmitter?.transmitFile("/storage/emulated/0/Android/data/com.anyun.h264/files/h264_1764574451071.h264")
                return true
            }else{
                return false
            }
        } catch (e: Exception) {
            Timber.e(e, "Failed to start H264Encoder")
            transmitter = null
            return false
        }
    }

    private fun startH264Encoder(): Boolean {
        if (h264Encoder != null) {
            Timber.w("H264Encoder is already running")
            return false
        }
        

        try {
            // 创建编码器
            h264Encoder = H264Encoder()
            

            // 设置编码参数
            h264Encoder?.setEncoderParams(640, 480, 25, 2000000)
            

            // 设置输出文件（可选）
            val outputFile = File(getExternalFilesDir(null), "test2.h264")
            h264Encoder?.setOutputFile(outputFile.absolutePath)
            h264Encoder?.setEnableFileOutput(false) // 启用文件输出
            

            // 设置UDP服务器地址（可选）
//             h264Encoder?.setServerAddress("58.48.93.67", 11935)
            h264Encoder?.setEnableNetworkTransmission(true)
             h264Encoder?.setServerAddress("192.168.16.138", 1078)
             h264Encoder?.setProtocolParams("013120122580", 1)
            
            h264Encoder?.setServerAddress("192.168.16.138", 1078)
            h264Encoder?.setProtocolParams("013120122580", 1)

            // 初始化并启动
            val cameraIdRange = intArrayOf(1, 2)
            val resolution = intArrayOf(640, 480)
            

            if (h264Encoder?.initialize(cameraIdRange, null, resolution, false) == true) {
                h264Encoder?.start()
                Timber.d("H264Encoder started successfully")
@@ -94,7 +137,7 @@
            return false
        }
    }
    

    private fun stopH264Encoder() {
        h264Encoder?.let { encoder ->
            try {
@@ -126,9 +169,9 @@
            text = "H264 编码器",
            style = MaterialTheme.typography.headlineMedium
        )
        

        Spacer(modifier = Modifier.height(32.dp))
        

        Button(
            onClick = onStartH264Click,
            enabled = !isRunning,
@@ -138,9 +181,9 @@
        ) {
            Text("启动 H264")
        }
        

        Spacer(modifier = Modifier.height(16.dp))
        

        Button(
            onClick = onStopH264Click,
            enabled = isRunning,
@@ -153,9 +196,9 @@
        ) {
            Text("停止 H264")
        }
        

        Spacer(modifier = Modifier.height(32.dp))
        

        if (isRunning) {
            Text(
                text = "编码器运行中...",