package com.anyun.h264;
|
|
import android.media.MediaCodec;
|
import android.media.MediaCodecInfo;
|
import android.media.MediaFormat;
|
import com.anyun.libusbcamera.UsbCamera;
|
import com.anyun.libusbcamera.WatermarkParam;
|
import com.anyun.h264.model.WatermarkInfo;
|
|
import java.io.File;
|
import java.io.FileOutputStream;
|
import java.io.IOException;
|
import java.nio.ByteBuffer;
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.concurrent.atomic.AtomicBoolean;
|
|
import timber.log.Timber;
|
|
/**
|
* H264视频编码器
|
* 使用UsbCamera获取视频数据，进行H264编码，并通过UDP按JT/T 1076-2016协议上传
|
*
|
* 使用示例：
|
* <pre>
|
* // 创建编码器
|
* H264Encoder encoder = new H264Encoder();
|
*
|
* // 设置编码参数
|
* encoder.setEncoderParams(640, 480, 25, 2000000);
|
*
|
* // 设置输出文件（可选，用于保存H264编码数据，可用VLC播放验证）
|
* // 使用应用外部存储目录（推荐）
|
* File outputFile = new File(context.getExternalFilesDir(null), "test.h264");
|
* encoder.setOutputFile(outputFile.getAbsolutePath());
|
* encoder.setEnableFileOutput(true); // 启用文件输出，设置为false则不写入文件
|
*
|
* // 设置UDP服务器地址（可选）
|
* encoder.setServerAddress("192.168.1.100", 8888);
|
* encoder.setProtocolParams("123456789012", (byte)1);
|
* encoder.setEnableNetworkTransmission(true); // 启用TCP/UDP网络传输，false表示禁用
|
*
|
* // 初始化并启动
|
* int[] cameraIdRange = {0, 0};
|
* int[] resolution = {640, 480};
|
* if (encoder.initialize(cameraIdRange, "camera", resolution, false)) {
|
* encoder.start();
|
* }
|
*
|
* // 停止编码
|
* encoder.stop();
|
* </pre>
|
*
|
* 生成的.h264文件可以用VLC播放器直接播放验证。
|
*/
|
public class H264Encoder {
|
private static final String TAG = "H264Encoder";
|
|
private UsbCamera usbCamera;
|
private MediaCodec encoder;
|
private Thread encodeThread;
|
private AtomicBoolean isRunning = new AtomicBoolean(false);
|
|
// 编码参数
|
private int width = 640;
|
private int height = 480;
|
private int frameRate = 15;
|
private int bitrate = 2000000; // 2Mbps
|
private int iFrameInterval = 2; // I帧间隔（秒）
|
|
// JT/T 1076-2016 协议工具类
|
private JT1076ProtocolHelper protocolHelper;
|
private long lastIFrameTime = 0; // 上一个I帧时间
|
private long lastFrameTime = 0; // 上一帧时间
|
|
// 文件输出
|
private FileOutputStream fileOutputStream;
|
private String outputFilePath;
|
private boolean enableFileOutput = false; // 是否启用文件输出
|
private boolean spsPpsWritten = false; // 标记SPS/PPS是否已写入
|
|
// 网络传输控制
|
private boolean enableNetworkTransmission = true; // 是否启用TCP/UDP网络传输
|
|
// SPS/PPS 缓存（用于网络传输）
|
private byte[] spsBuffer = null; // SPS 缓存
|
private byte[] ppsBuffer = null; // PPS 缓存
|
|
// 编码回调
|
public interface OnFrameEncodedCallback {
|
void onFrameEncoded(byte[] data, boolean isKeyFrame);
|
}
|
private OnFrameEncodedCallback callback;
|
|
public H264Encoder() {
|
this.usbCamera = new UsbCamera();
|
this.protocolHelper = new JT1076ProtocolHelper();
|
protocolHelper.setProtocolType(JT1076ProtocolHelper.PROTOCOL_TYPE_TCP);//设置为tcp传输
|
}
|
|
/**
|
* 设置编码参数
|
*/
|
public void setEncoderParams(int width, int height, int frameRate, int bitrate) {
|
this.width = width;
|
this.height = height;
|
this.frameRate = frameRate;
|
this.bitrate = bitrate;
|
}
|
|
/**
|
* 设置UDP服务器地址
|
*/
|
public void setServerAddress(String ip, int port) {
|
protocolHelper.setServerAddress(ip, port);
|
}
|
|
/**
|
* 设置SIM卡号和逻辑通道号
|
*/
|
public void setProtocolParams(String simCardNumber, byte logicalChannelNumber) {
|
protocolHelper.setProtocolParams(simCardNumber, logicalChannelNumber);
|
}
|
|
/**
|
* 设置编码回调
|
*/
|
public void setOnFrameEncodedCallback(OnFrameEncodedCallback callback) {
|
this.callback = callback;
|
}
|
|
/**
|
* 设置输出文件路径（用于保存H264编码数据）
|
* @param filePath 文件路径，例如："/sdcard/test.h264" 或使用Context.getExternalFilesDir()
|
*/
|
public void setOutputFile(String filePath) {
|
this.outputFilePath = filePath;
|
}
|
|
/**
|
* 设置是否启用文件输出
|
* @param enable true表示启用文件输出，false表示禁用
|
*/
|
public void setEnableFileOutput(boolean enable) {
|
Timber.d("开启h264文件输出");
|
this.enableFileOutput = enable;
|
}
|
|
/**
|
* 设置是否启用TCP/UDP网络传输
|
* @param enable true表示启用网络传输，false表示禁用
|
*/
|
public void setEnableNetworkTransmission(boolean enable) {
|
this.enableNetworkTransmission = enable;
|
Timber.d("Network transmission " + (enable ? "enabled" : "disabled"));
|
}
|
|
/**
|
* 设置水印信息
|
* @param watermarkInfo 水印信息对象
|
*/
|
public void setWatermarkInfo(WatermarkInfo watermarkInfo) {
|
if (watermarkInfo == null) {
|
Timber.w("WatermarkInfo is null, disabling watermark");
|
usbCamera.enableWatermark(false, null);
|
return;
|
}
|
|
try {
|
// 构建水印文本列表（分行显示，每行一个信息项）
|
ArrayList<WatermarkParam> watermarkParams = new ArrayList<>();
|
|
// 从左上角开始，每行间隔25像素
|
int yOffset = 30;
|
int xOffset = 10;
|
|
// 车牌号
|
if (watermarkInfo.getPlateNumber() != null && !watermarkInfo.getPlateNumber().isEmpty()) {
|
watermarkParams.add(new WatermarkParam(xOffset, yOffset,
|
"车牌:" + watermarkInfo.getPlateNumber()));
|
yOffset += 25;
|
}
|
|
// 学员姓名
|
if (watermarkInfo.getStudent() != null && !watermarkInfo.getStudent().isEmpty()) {
|
watermarkParams.add(new WatermarkParam(xOffset, yOffset,
|
"学员:" + watermarkInfo.getStudent()));
|
yOffset += 25;
|
}
|
|
// 教练姓名
|
if (watermarkInfo.getCoach() != null && !watermarkInfo.getCoach().isEmpty()) {
|
watermarkParams.add(new WatermarkParam(xOffset, yOffset,
|
"教练:" + watermarkInfo.getCoach()));
|
yOffset += 25;
|
}
|
|
// 位置信息（纬度,经度）
|
if (watermarkInfo.getLongitude() != null && watermarkInfo.getLatitude() != null) {
|
watermarkParams.add(new WatermarkParam(xOffset, yOffset,
|
String.format("位置:%.6f,%.6f", watermarkInfo.getLatitude(), watermarkInfo.getLongitude())));
|
yOffset += 25;
|
}
|
|
// 驾校名称
|
if (watermarkInfo.getDrivingSchool() != null && !watermarkInfo.getDrivingSchool().isEmpty()) {
|
watermarkParams.add(new WatermarkParam(xOffset, yOffset,
|
"驾校:" + watermarkInfo.getDrivingSchool()));
|
yOffset += 25;
|
}
|
|
// 车速
|
if (watermarkInfo.getSpeed() != null) {
|
watermarkParams.add(new WatermarkParam(xOffset, yOffset,
|
String.format("车速:%.1fkm/h", watermarkInfo.getSpeed())));
|
}
|
|
if (!watermarkParams.isEmpty()) {
|
// 启用水印，使用默认字体路径（如果系统有字体文件）
|
// 颜色：0-REVERSE（反色），1-BLACK，2-WHITE，3-RED，4-GREEN，5-BLUE
|
// 字体大小、倍数可以根据需要调整
|
String fontPath = "/system/fonts/DroidSans.ttf"; // 默认字体路径，如果不存在可以传null
|
usbCamera.enableWatermark(true, fontPath);
|
|
// 设置水印：颜色（2=白色），字体大小（24），倍数（1），文本列表
|
usbCamera.setWatermark(2, 24, 1, watermarkParams);
|
|
Timber.d("Watermark set successfully: %s", watermarkInfo);
|
} else {
|
Timber.w("No watermark text to display, disabling watermark");
|
usbCamera.enableWatermark(false, null);
|
}
|
} catch (Exception e) {
|
Timber.e(e, "Failed to set watermark");
|
usbCamera.enableWatermark(false, null);
|
}
|
}
|
|
/**
|
* 初始化摄像头和编码器
|
*/
|
public boolean initialize(int[] cameraIdRange, String cameraName, int[] resolution, boolean ayCamera) {
|
try {
|
// 1. setenv
|
usbCamera.setenv();
|
|
// 2. prepareCamera (最多尝试3次：初始1次 + 重试2次)
|
int[] actualResolution = new int[2];
|
actualResolution[0] = 640;
|
actualResolution[1] = 480;
|
System.arraycopy(resolution, 0, actualResolution, 0, 2);
|
|
int result = -1;
|
int maxRetries = 3; // 总共尝试3次
|
for (int attempt = 0; attempt < maxRetries; attempt++) {
|
result = usbCamera.prepareCamera(cameraIdRange, cameraName, actualResolution, ayCamera);
|
if (result == 0) {
|
// 成功，跳出循环
|
if (attempt > 0) {
|
Timber.d("prepareCamera succeeded on attempt " + (attempt + 1));
|
}
|
break;
|
} else {
|
// 失败，记录日志
|
Timber.w( "prepareCamera failed on attempt " + (attempt + 1) + ": " + result);
|
if (attempt < maxRetries - 1) {
|
Timber.d( "Retrying prepareCamera...");
|
}
|
}
|
}
|
|
if (result != 0) {
|
Timber.e("prepareCamera failed after " + maxRetries + " attempts: " + result);
|
return false;
|
}
|
|
// 更新实际分辨率
|
width = actualResolution[0];
|
height = actualResolution[1];
|
Timber.d("Camera initialized with resolution: " + width + "x" + height);
|
|
// 3. 初始化H264编码器
|
initEncoder();
|
|
// 4. 初始化Socket（UDP或TCP，根据协议类型自动选择）
|
// 只有在启用网络传输时才初始化Socket
|
if (enableNetworkTransmission) {
|
if (!protocolHelper.initializeSocket()) {
|
return false;
|
}
|
} else {
|
Timber.d("Network transmission disabled, skipping socket initialization");
|
}
|
|
// 5. 初始化文件输出（仅创建文件，SPS/PPS在第一次输出时写入）
|
if (enableFileOutput && outputFilePath != null && !outputFilePath.isEmpty()) {
|
if (!initFileOutput()) {
|
Timber.w("File output initialization failed, continuing without file output");
|
}
|
}
|
|
return true;
|
} catch (Exception e) {
|
Timber.e(e,"Initialize failed");
|
return false;
|
}
|
}
|
|
/**
|
* 初始化H264编码器
|
*/
|
private void initEncoder() throws IOException {
|
MediaFormat format = MediaFormat.createVideoFormat(MediaFormat.MIMETYPE_VIDEO_AVC, width, height);
|
format.setInteger(MediaFormat.KEY_COLOR_FORMAT, MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420Flexible);
|
format.setInteger(MediaFormat.KEY_BIT_RATE, bitrate);
|
format.setInteger(MediaFormat.KEY_FRAME_RATE, frameRate);
|
format.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, iFrameInterval);
|
|
encoder = MediaCodec.createEncoderByType(MediaFormat.MIMETYPE_VIDEO_AVC);
|
encoder.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
|
encoder.start();
|
|
// 清理 SPS/PPS 缓存
|
spsBuffer = null;
|
ppsBuffer = null;
|
|
Timber.d( "H264 encoder initialized");
|
}
|
|
/**
|
* 初始化文件输出
|
* @return 是否成功
|
*/
|
private boolean initFileOutput() {
|
try {
|
File file = new File(outputFilePath);
|
File parentDir = file.getParentFile();
|
if (parentDir != null && !parentDir.exists()) {
|
boolean created = parentDir.mkdirs();
|
if (!created && !parentDir.exists()) {
|
Timber.e("Failed to create parent directory: " + parentDir.getAbsolutePath());
|
return false;
|
}
|
}
|
|
fileOutputStream = new FileOutputStream(file);
|
spsPpsWritten = false;
|
|
Timber.d("File output initialized: " + outputFilePath);
|
return true;
|
} catch (Exception e) {
|
Timber.e(e,"Initialize file output failed");
|
if (fileOutputStream != null) {
|
try {
|
fileOutputStream.close();
|
} catch (IOException ie) {
|
Timber.e(ie, "Close file output stream failed");
|
}
|
fileOutputStream = null;
|
}
|
return false;
|
}
|
}
|
|
/**
|
* 写入SPS/PPS到文件（从CSD或关键帧数据中提取）
|
*/
|
private void writeSpsPpsToFile() {
|
if (!enableFileOutput || fileOutputStream == null || spsPpsWritten) {
|
return;
|
}
|
|
try {
|
// 尝试从编码器输出格式中获取CSD
|
MediaFormat format = encoder.getOutputFormat();
|
ByteBuffer spsBuffer = format.getByteBuffer("csd-0"); // SPS
|
ByteBuffer ppsBuffer = format.getByteBuffer("csd-1"); // PPS
|
|
if (spsBuffer != null && ppsBuffer != null) {
|
// CSD格式通常是AVCC格式，需要转换为Annex-B
|
byte[] sps = new byte[spsBuffer.remaining()];
|
byte[] pps = new byte[ppsBuffer.remaining()];
|
spsBuffer.get(sps);
|
ppsBuffer.get(pps);
|
|
// 写入SPS和PPS到文件（Annex-B格式）
|
byte[] nalStartCode = {0x00, 0x00, 0x00, 0x01};
|
|
// CSD数据通常是AVCC格式：前4字节是大端格式的长度，后面是NAL数据
|
// 检查并跳过长度前缀
|
int spsOffset = 0;
|
int ppsOffset = 0;
|
int spsLength = sps.length;
|
int ppsLength = pps.length;
|
|
// 检查是否为AVCC格式（前4字节是长度，通常不会是0x00000001）
|
if (sps.length > 4 && (sps[0] != 0x00 || sps[1] != 0x00 || sps[2] != 0x00 || sps[3] != 0x01)) {
|
// AVCC格式：前4字节是长度（大端）
|
spsOffset = 4;
|
spsLength = sps.length - 4;
|
}
|
if (pps.length > 4 && (pps[0] != 0x00 || pps[1] != 0x00 || pps[2] != 0x00 || pps[3] != 0x01)) {
|
// AVCC格式：前4字节是长度（大端）
|
ppsOffset = 4;
|
ppsLength = pps.length - 4;
|
}
|
|
// 写入SPS
|
fileOutputStream.write(nalStartCode);
|
fileOutputStream.write(sps, spsOffset, spsLength);
|
|
// 写入PPS
|
fileOutputStream.write(nalStartCode);
|
fileOutputStream.write(pps, ppsOffset, ppsLength);
|
fileOutputStream.flush();
|
|
spsPpsWritten = true;
|
Timber.d("SPS/PPS written to file, SPS size: " + spsLength + ", PPS size: " + ppsLength);
|
} else {
|
Timber.w("SPS/PPS not found in CSD, will extract from first key frame");
|
}
|
} catch (Exception e) {
|
Timber.e(e,"Write SPS/PPS to file error");
|
}
|
}
|
|
/**
|
* 开始编码
|
*/
|
public void start() {
|
if (isRunning.get()) {
|
Timber.w("Encoder is already running");
|
return;
|
}
|
|
isRunning.set(true);
|
|
// 启动编码线程
|
encodeThread = new Thread(new Runnable() {
|
@Override
|
public void run() {
|
encodeLoop();
|
}
|
});
|
encodeThread.start();
|
|
Timber.d("H264 encoder started");
|
}
|
|
/**
|
* 编码循环
|
*/
|
private void encodeLoop() {
|
// YUV420P格式: Y平面 + U平面 + V平面
|
// Y平面大小 = width * height
|
// U平面大小 = width * height / 4
|
// V平面大小 = width * height / 4
|
// 总大小 = width * height * 3 / 2
|
byte[] yuvBuffer = new byte[width * height * 3 / 2];
|
|
MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
|
|
while (isRunning.get()) {
|
try {
|
// processCamera - 读取一帧
|
int processResult = usbCamera.processCamera();
|
if (processResult != 0) {
|
Timber.w("processCamera returned: " + processResult);
|
Thread.sleep(10);
|
continue;
|
}
|
|
// 获取RGBA数据 (type=1 表示推流，输出YUV420P格式)
|
usbCamera.rgba(0, yuvBuffer);
|
|
// 将YUV420P数据送入编码器
|
long timestamp = System.currentTimeMillis();
|
encodeFrame(nv12ToNV21(yuvBuffer,width,height), timestamp, bufferInfo);
|
|
} catch (Exception e) {
|
Timber.e(e, "Encode loop error");
|
try {
|
Thread.sleep(100);
|
} catch (InterruptedException ie) {
|
break;
|
}
|
}
|
}
|
|
Timber.d( "Encode loop exited");
|
}
|
|
/**
|
* 编码一帧数据
|
*/
|
private void encodeFrame(byte[] yuvData, long timestamp, MediaCodec.BufferInfo bufferInfo) {
|
try {
|
// 获取输入缓冲区
|
int inputBufferIndex = encoder.dequeueInputBuffer(10000);
|
if (inputBufferIndex >= 0) {
|
ByteBuffer inputBuffer = encoder.getInputBuffer(inputBufferIndex);
|
if (inputBuffer != null) {
|
inputBuffer.clear();
|
inputBuffer.put(yuvData);
|
encoder.queueInputBuffer(inputBufferIndex, 0, yuvData.length, timestamp * 1000, 0);
|
}
|
}
|
|
// 获取输出数据
|
int outputBufferIndex = encoder.dequeueOutputBuffer(bufferInfo, 0);
|
while (outputBufferIndex >= 0) {
|
ByteBuffer outputBuffer = encoder.getOutputBuffer(outputBufferIndex);
|
if (outputBuffer != null && bufferInfo.size > 0) {
|
// 复制编码数据
|
byte[] nalUnit = new byte[bufferInfo.size];
|
outputBuffer.position(bufferInfo.offset);
|
outputBuffer.get(nalUnit, 0, bufferInfo.size);
|
|
// 解析并处理 NAL 单元
|
processNalUnit(nalUnit, timestamp);
|
|
// 写入文件（保持原有逻辑）
|
boolean isKeyFrame = (bufferInfo.flags & MediaCodec.BUFFER_FLAG_KEY_FRAME) != 0;
|
writeToFile(nalUnit, isKeyFrame);
|
|
// 回调
|
if (callback != null) {
|
callback.onFrameEncoded(nalUnit, isKeyFrame);
|
}
|
}
|
|
encoder.releaseOutputBuffer(outputBufferIndex, false);
|
outputBufferIndex = encoder.dequeueOutputBuffer(bufferInfo, 0);
|
}
|
|
} catch (Exception e) {
|
Timber.e(e,"Encode frame error");
|
}
|
}
|
|
/**
|
* 处理 NAL 单元，识别类型并分别处理
|
*/
|
private void processNalUnit(byte[] data, long timestamp) {
|
if (data == null || data.length < 5) {
|
return;
|
}
|
|
// MediaCodec 输出的数据是 Annex-B 格式，可能包含多个 NAL 单元
|
// 每个 NAL 单元以 0x00000001 或 0x000001 开头
|
int offset = 0;
|
while (offset < data.length) {
|
// 查找起始码
|
int startCodePos = findStartCode(data, offset);
|
if (startCodePos == -1) {
|
break; // 没有找到起始码，结束
|
}
|
|
// 跳过起始码，找到 NAL 单元数据
|
int nalStart = startCodePos;
|
int startCodeLength = (startCodePos + 2 < data.length &&
|
data[startCodePos] == 0x00 &&
|
data[startCodePos + 1] == 0x00 &&
|
data[startCodePos + 2] == 0x01) ? 3 : 4;
|
int nalDataStart = nalStart + startCodeLength;
|
|
// 查找下一个起始码，确定当前 NAL 单元的结束位置
|
int nextStartCodePos = findStartCode(data, nalDataStart);
|
int nalDataEnd = (nextStartCodePos == -1) ? data.length : nextStartCodePos;
|
int nalDataLength = nalDataEnd - nalDataStart;
|
|
if (nalDataLength > 0 && nalDataStart < data.length) {
|
// 提取 NAL 单元数据（包含起始码）
|
byte[] nalUnit = new byte[nalDataLength + startCodeLength];
|
System.arraycopy(data, nalStart, nalUnit, 0, startCodeLength);
|
System.arraycopy(data, nalDataStart, nalUnit, startCodeLength, nalDataLength);
|
|
// 获取 NAL 类型（起始码后的第一个字节的低5位）
|
int nalType = (nalUnit[startCodeLength] & 0x1F);
|
|
// 根据 NAL 类型处理
|
switch (nalType) {
|
case 7: // SPS
|
spsBuffer = nalUnit.clone();
|
Timber.d("SPS cached, size: %d", spsBuffer.length);
|
break;
|
|
case 8: // PPS
|
ppsBuffer = nalUnit.clone();
|
Timber.d("PPS cached, size: %d", ppsBuffer.length);
|
break;
|
|
case 5: // IDR 帧 (关键帧)
|
// 关键帧必须与 SPS、PPS 一起发送
|
if (spsBuffer != null && ppsBuffer != null) {
|
// 将 SPS, PPS, IDR 帧数据组合成一个完整的"帧数据单元"
|
byte[] frameData = combineFrameData(spsBuffer, ppsBuffer, nalUnit);
|
// 发送组合后的数据
|
sendEncodedData(frameData, timestamp, true);
|
} else {
|
Timber.w("Received IDR frame, but SPS or PPS not ready, dropping");
|
// 如果没有 SPS/PPS，仍然发送 IDR 帧（可能包含在数据中）
|
sendEncodedData(nalUnit, timestamp, true);
|
}
|
break;
|
|
case 1: // 非 IDR 帧 (P 帧)
|
// 直接发送 P 帧
|
sendEncodedData(nalUnit, timestamp, false);
|
break;
|
|
default:
|
// 其他 NALU 类型（如 SEI 等），根据协议决定是否处理
|
// 这里可以选择发送或忽略
|
Timber.d("NAL unit type %d, size: %d", nalType, nalUnit.length);
|
break;
|
}
|
}
|
|
// 移动到下一个可能的起始位置
|
offset = nalDataEnd;
|
}
|
}
|
|
/**
|
* 查找起始码位置（0x00000001 或 0x000001）
|
* @param data 数据数组
|
* @param startPos 开始搜索的位置
|
* @return 起始码位置，如果未找到返回 -1
|
*/
|
private int findStartCode(byte[] data, int startPos) {
|
for (int i = startPos; i < data.length - 2; i++) {
|
if (data[i] == 0x00 && data[i + 1] == 0x00) {
|
if (i + 2 < data.length && data[i + 2] == 0x01) {
|
return i; // 找到 0x000001
|
}
|
if (i + 3 < data.length && data[i + 2] == 0x00 && data[i + 3] == 0x01) {
|
return i; // 找到 0x00000001
|
}
|
}
|
}
|
return -1;
|
}
|
|
/**
|
* 组合 SPS、PPS 和 IDR 帧数据
|
* @param sps SPS 数据（包含起始码）
|
* @param pps PPS 数据（包含起始码）
|
* @param idr IDR 帧数据（包含起始码）
|
* @return 组合后的数据
|
*/
|
private byte[] combineFrameData(byte[] sps, byte[] pps, byte[] idr) {
|
int totalLength = sps.length + pps.length + idr.length;
|
byte[] combined = new byte[totalLength];
|
int offset = 0;
|
|
// 复制 SPS
|
System.arraycopy(sps, 0, combined, offset, sps.length);
|
offset += sps.length;
|
|
// 复制 PPS
|
System.arraycopy(pps, 0, combined, offset, pps.length);
|
offset += pps.length;
|
|
// 复制 IDR 帧
|
System.arraycopy(idr, 0, combined, offset, idr.length);
|
|
Timber.d("Combined SPS/PPS/IDR frame, total size: %d (SPS: %d, PPS: %d, IDR: %d)",
|
totalLength, sps.length, pps.length, idr.length);
|
|
return combined;
|
}
|
|
/**
|
* 将编码数据写入H264文件
|
*/
|
private void writeToFile(byte[] data, boolean isKeyFrame) {
|
if (!enableFileOutput || fileOutputStream == null) {
|
return;
|
}
|
|
try {
|
// 如果是第一个关键帧，确保SPS/PPS已写入
|
if (isKeyFrame && !spsPpsWritten) {
|
writeSpsPpsToFile();
|
|
// 如果从CSD获取失败，尝试从关键帧数据中提取
|
// MediaCodec输出的关键帧通常已经包含SPS/PPS，但为了确保文件完整性，
|
// 我们已经从CSD写入，这里直接写入关键帧数据即可
|
if (!spsPpsWritten) {
|
Timber.d("SPS/PPS will be included in key frame data");
|
}
|
}
|
|
// MediaCodec输出的H264数据已经是Annex-B格式（包含0x00000001分隔符）
|
// 直接写入文件即可
|
fileOutputStream.write(data);
|
fileOutputStream.flush();
|
} catch (IOException e) {
|
Timber.e(e, "Write to file error");
|
}
|
}
|
|
/**
|
* 发送编码后的数据（按JT/T 1076-2016协议打包）
|
*/
|
private void sendEncodedData(byte[] data, long timestamp, boolean isKeyFrame) {
|
// 如果未启用网络传输，直接返回
|
if (!enableNetworkTransmission) {
|
return;
|
}
|
|
try {
|
// 计算时间间隔
|
long currentTime = System.currentTimeMillis();
|
long lastIFrameInterval = (lastIFrameTime > 0) ? (currentTime - lastIFrameTime) : 0;
|
long lastFrameInterval = (lastFrameTime > 0) ? (currentTime - lastFrameTime) : 0;
|
|
if (isKeyFrame) {
|
lastIFrameTime = currentTime;
|
}
|
lastFrameTime = currentTime;
|
|
// 判断帧类型
|
int dataType = isKeyFrame ? JT1076ProtocolHelper.DATA_TYPE_I_FRAME :
|
JT1076ProtocolHelper.DATA_TYPE_P_FRAME;
|
|
// 分包发送（如果数据超过最大包大小）
|
int offset = 0;
|
int totalPackets = (int) Math.ceil((double) data.length / JT1076ProtocolHelper.MAX_PACKET_SIZE);
|
|
for (int i = 0; i < totalPackets; i++) {
|
int packetDataSize = Math.min(JT1076ProtocolHelper.MAX_PACKET_SIZE, data.length - offset);
|
byte[] packetData = Arrays.copyOfRange(data, 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;
|
}
|
|
} catch (Exception e) {
|
Timber.e(e,"Send encoded data error");
|
}
|
}
|
|
/**
|
* 停止编码
|
*/
|
public void stop() {
|
if (!isRunning.get()) {
|
return;
|
}
|
|
isRunning.set(false);
|
|
// 等待编码线程结束
|
if (encodeThread != null) {
|
try {
|
encodeThread.join(2000);
|
} catch (InterruptedException e) {
|
Timber.e(e, "Wait encode thread error");
|
}
|
}
|
|
// 停止摄像头
|
if (usbCamera != null) {
|
usbCamera.stopCamera();
|
}
|
|
// 释放编码器
|
if (encoder != null) {
|
try {
|
encoder.stop();
|
encoder.release();
|
encoder = null;
|
} catch (Exception e) {
|
Timber.e(e, "Release encoder error");
|
}
|
}
|
|
// 关闭Socket（UDP或TCP，根据协议类型自动选择）
|
// 只有在启用网络传输时才需要关闭Socket
|
if (enableNetworkTransmission && protocolHelper != null) {
|
protocolHelper.closeSocket();
|
}
|
|
// 关闭文件输出
|
closeFileOutput();
|
|
// 清理 SPS/PPS 缓存
|
spsBuffer = null;
|
ppsBuffer = null;
|
|
Timber.d("H264 encoder stopped");
|
}
|
|
/**
|
* 关闭文件输出
|
*/
|
private void closeFileOutput() {
|
if (fileOutputStream != null) {
|
try {
|
fileOutputStream.flush();
|
fileOutputStream.close();
|
Timber.d("File output closed: " + outputFilePath);
|
} catch (IOException e) {
|
Timber.e(e, "Close file output error");
|
} finally {
|
fileOutputStream = null;
|
spsPpsWritten = false;
|
}
|
}
|
}
|
|
/**
|
* 释放资源
|
*/
|
public void release() {
|
stop();
|
}
|
|
byte[] ret = null;
|
// YYYYYYYY UVUV(nv12)--> YYYYYYYY VUVU(nv21)
|
private byte[] nv12ToNV21(byte[] nv12, int width, int height) {
|
// Log.i(TAG,"nv12toNv21:"+width+"height:"+height);
|
if (ret == null){
|
ret = new byte[width * height * 3 /2];
|
}
|
int framesize = width * height;
|
int i = 0, j = 0;
|
// 拷贝Y分量
|
System.arraycopy(nv12, 0,ret , 0, framesize);
|
// 拷贝UV分量
|
for (j = framesize; j < nv12.length; j += 2) {
|
ret[j] = nv12[j+1];
|
ret[j+1] = nv12[j];
|
}
|
return ret;
|
}
|
}
|
