|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <pthread.h>
|
|
|
|
#include <time.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
|
|
|
|
#include "JZsdkLib.h"
|
|
|
|
#include "BaseConfig.h"
|
|
|
|
#include "JZsdk_usb_bulk/JZsdk_usb_bulk.h"
|
|
|
|
|
|
|
|
#include "IRCUT/ircut.h"
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef RTK_MPP_STATUS_ON
|
|
|
|
#include "MediaProc/MultProc/RTK_mmp/RTK_mmp.h"
|
|
|
|
#include "MediaProc/MultProc/RTK_mmp/Dec/RTK_mmp_dec.h"
|
|
|
|
#include "MediaProc/MultProc/RTK_mmp/Enc/RTK_mmp_enc.h"
|
|
|
|
#include "MediaProc/Camera/Camera.h"
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef RTK_RGA_STATUS_ON
|
|
|
|
|
|
|
|
#include "MediaProc/RgaProc/RK_Rga/RK_Rga.h"
|
|
|
|
|
|
|
|
//c1的rga结构体
|
|
|
|
typedef struct C1_RgaInfo
|
|
|
|
{
|
|
|
|
//源图像
|
|
|
|
RK_RgaImage *src_img;
|
|
|
|
|
|
|
|
//裁剪图像
|
|
|
|
RK_RgaImage *corp_img;
|
|
|
|
|
|
|
|
//目标图像
|
|
|
|
RK_RgaImage *dst_img;
|
|
|
|
|
|
|
|
//放大倍数
|
|
|
|
int scale;
|
|
|
|
|
|
|
|
}C1_RgaInfo;
|
|
|
|
|
|
|
|
static C1_RgaInfo *g_C1_RgaIrcInfo = NULL;
|
|
|
|
static C1_RgaInfo *g_C1_RgaOptInfo = NULL;
|
|
|
|
|
|
|
|
static unsigned char *g_MixedIrc_Buffer = NULL;
|
|
|
|
|
|
|
|
static unsigned char *g_MixedOpt_Buffer = NULL;
|
|
|
|
static unsigned int g_MixedOptBuffer_UseFlag = JZ_FLAGCODE_OFF;
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef MEDIA_PROC_CONFIG_STATUS_ON
|
|
|
|
|
|
|
|
#include "MediaProc/Camera/Cam_FrameCatch/Cam_FrameCatch.h"
|
|
|
|
#include "MediaProc/MediaParm.h"
|
|
|
|
#include "MediaProc/VideoMgmt/VideoStreamPush/VideoStream_Push.h"
|
|
|
|
#include "MediaProc/VideoMgmt/VideoMgmt.h"
|
|
|
|
#include "MediaProc/IRC_funtion/IRC_Param.h"
|
|
|
|
#include "MediaProc/IRC_funtion/IRC_funtion.h"
|
|
|
|
#include "MediaProc/MediaProc_Param.h"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void *g_usb_index = NULL;
|
|
|
|
|
|
|
|
// 定义 昆腾的 帧头长度和帧头内容
|
|
|
|
#define FRAME_HEADER_SIZE 4
|
|
|
|
static const unsigned char FRAME_HEADER[FRAME_HEADER_SIZE] = {0xaa, 0xbb, 0xcc, 0xdd};
|
|
|
|
#define NSEC_PER_SEC 1000000000L //1秒的纳秒数
|
|
|
|
#define TARGET_FPS 30
|
|
|
|
|
|
|
|
static unsigned char FrameBuffer[FIRST_HEIGHT * FIRST_WIDTH *2]; //用于存储帧数据的缓冲区
|
|
|
|
static unsigned int FrameBufferLen = 0; //用于存储帧数据的长度
|
|
|
|
static FrameBuffer_UseFlag = JZ_FLAGCODE_OFF;
|
|
|
|
|
|
|
|
#ifdef RTK_RGA_STATUS_ON
|
|
|
|
static T_JZsdkReturnCode JZC1_RgaDeal(C1_RgaInfo *rga_info, int resize, unsigned char *image, unsigned int *imgage_size);
|
|
|
|
static T_JZsdkReturnCode JZC1_RgaInit(C1_RgaInfo **rgaInfo, int dst_width, int dst_height, int dst_format);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
//数据推送函数
|
|
|
|
static T_JZsdkReturnCode JZC1_PushFrame(int CameraIndex, unsigned char* data, unsigned int data_len)
|
|
|
|
{
|
|
|
|
int currentIndex = VideoMgmt_GetVideoStreamFlowIndexNum(); //获取当前视频流索引
|
|
|
|
//无视频流
|
|
|
|
if (currentIndex == 0)
|
|
|
|
{
|
|
|
|
//不推送视频
|
|
|
|
return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
//红外相机
|
|
|
|
if (currentIndex == VIDEOMGMT_STREAMING_FLOW_INDEX_FIRST && CameraIndex == VIDEOMGMT_STREAMING_FLOW_INDEX_FIRST)
|
|
|
|
{
|
|
|
|
|
|
|
|
//推送数据到流转模块
|
|
|
|
VideoMgmt_Single_FrameIn(data, data_len);
|
|
|
|
}
|
|
|
|
|
|
|
|
//光学相机
|
|
|
|
if(CameraIndex == VIDEOMGMT_STREAMING_FLOW_INDEX_SECOND && currentIndex == VIDEOMGMT_STREAMING_FLOW_INDEX_SECOND)
|
|
|
|
{
|
|
|
|
//推送数据到流转模块
|
|
|
|
VideoMgmt_Single_FrameIn(data, data_len);
|
|
|
|
}
|
|
|
|
|
|
|
|
//组合视频流
|
|
|
|
if (currentIndex == VIDEOMGMT_STREAMING_FLOW_INDEX_THIRD && CameraIndex == VIDEOMGMT_STREAMING_FLOW_INDEX_THIRD)
|
|
|
|
{
|
|
|
|
//推送数据到流转模块
|
|
|
|
VideoMgmt_Single_FrameIn(data, data_len);
|
|
|
|
}
|
|
|
|
|
|
|
|
return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
static T_JZsdkReturnCode JZC1_OptDeal(unsigned char *data, unsigned int data_len)
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef RTK_MPP_STATUS_ON
|
|
|
|
|
|
|
|
//JZSDK_LOG_INFO("JZC1_OptDeal");
|
|
|
|
|
|
|
|
MppFrame yuv_data = NULL; //用于传递yuv数据的地址
|
|
|
|
MppPacket Packet = NULL;
|
|
|
|
|
|
|
|
//输入数据进入解码器
|
|
|
|
RTK_mmp_dec_input(JZsdk_RtkMmpGetDecHandleAddr(1), data, data_len, &yuv_data);
|
|
|
|
|
|
|
|
// int width = mpp_frame_get_width(yuv_data);
|
|
|
|
// int height = mpp_frame_get_height(yuv_data);
|
|
|
|
// int h_stride = mpp_frame_get_hor_stride(yuv_data);
|
|
|
|
// int v_stride = mpp_frame_get_ver_stride(yuv_data);
|
|
|
|
|
|
|
|
// JZSDK_LOG_INFO("w:%d h:%d hor:%d ver:%d",width,height,h_stride,v_stride);
|
|
|
|
|
|
|
|
//光学数据缩放
|
|
|
|
int resize = JZ_FLAGCODE_OFF;
|
|
|
|
Camera_param(JZ_FLAGCODE_GET, CAMERA_RESIZE, &resize);
|
|
|
|
|
|
|
|
//将size转化为倍数
|
|
|
|
int ZoomRatio = 0;
|
|
|
|
switch (resize)
|
|
|
|
{
|
|
|
|
case 0:
|
|
|
|
ZoomRatio = JZ_FLAGCODE_OFF;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 1:
|
|
|
|
ZoomRatio = 2;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 2:
|
|
|
|
ZoomRatio = 4;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 3:
|
|
|
|
ZoomRatio = 8;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
ZoomRatio = JZ_FLAGCODE_OFF;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if (ZoomRatio != JZ_FLAGCODE_OFF)
|
|
|
|
{
|
|
|
|
|
|
|
|
MppBuffer temp = mpp_frame_get_buffer(yuv_data);
|
|
|
|
RK_U32 h = mpp_frame_get_hor_stride(yuv_data);
|
|
|
|
RK_U32 w = mpp_frame_get_ver_stride(yuv_data);
|
|
|
|
|
|
|
|
int size = (h * w * 1.5);
|
|
|
|
|
|
|
|
unsigned char *temp_data = (unsigned char *)malloc(size);
|
|
|
|
memcpy(temp_data, mpp_buffer_get_ptr(temp), size);
|
|
|
|
|
|
|
|
JZC1_RgaDeal(g_C1_RgaOptInfo, ZoomRatio, temp_data, &size);
|
|
|
|
|
|
|
|
//重新将数据放回
|
|
|
|
memcpy(mpp_buffer_get_ptr(temp), temp_data, size);
|
|
|
|
|
|
|
|
free(temp_data);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//将数据放入混合缓冲区
|
|
|
|
MppBuffer temp = mpp_frame_get_buffer(yuv_data);
|
|
|
|
if (g_MixedOpt_Buffer != NULL && g_MixedOptBuffer_UseFlag == JZ_FLAGCODE_OFF)
|
|
|
|
{
|
|
|
|
g_MixedOptBuffer_UseFlag = JZ_FLAGCODE_ON;
|
|
|
|
memcpy(g_MixedOpt_Buffer, mpp_buffer_get_ptr(temp), (mpp_frame_get_hor_stride(yuv_data) * mpp_frame_get_ver_stride(yuv_data) * 1.5));
|
|
|
|
g_MixedOptBuffer_UseFlag = JZ_FLAGCODE_OFF;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//将返回的数据输入进编码器
|
|
|
|
RTK_mmp_enc_yuv_to_h264_byFrame(JZsdk_RtkMmpGetEncHandleAddr(1), yuv_data, &Packet);
|
|
|
|
|
|
|
|
//获取数据指针与长度
|
|
|
|
int packet_len = mpp_packet_get_length(Packet);
|
|
|
|
void *ptr = mpp_packet_get_pos(Packet);
|
|
|
|
|
|
|
|
//推送视频流
|
|
|
|
JZC1_PushFrame(2, (unsigned char *)ptr, packet_len);
|
|
|
|
|
|
|
|
//释放掉编码图像
|
|
|
|
mpp_packet_deinit(&Packet);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
//红外数据纠正函数, 暂定全部替换
|
|
|
|
static T_JZsdkReturnCode JZC1_Irc_DataCorrect(unsigned char *data)
|
|
|
|
{
|
|
|
|
//像素修正
|
|
|
|
data[0] = data[5];
|
|
|
|
data[1] = data[6];
|
|
|
|
data[2] = data[5];
|
|
|
|
data[3] = data[6];
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//在这里将灰度图数据转换成目标数据
|
|
|
|
static T_JZsdkReturnCode JZC1_IrcDeal(unsigned char *data, unsigned int data_len)
|
|
|
|
{
|
|
|
|
//JZSDK_LOG_DEBUG("irc数据处理");
|
|
|
|
if (data_len == 0)
|
|
|
|
{
|
|
|
|
JZSDK_LOG_ERROR("无数据错误");
|
|
|
|
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
//红外数据纠正处理
|
|
|
|
JZC1_Irc_DataCorrect(data);
|
|
|
|
|
|
|
|
//将 8位的raw数据 合并为16位数据
|
|
|
|
U16_t * u16Data = (U16_t *)malloc(sizeof(U16_t) * (data_len / 2));
|
|
|
|
int u16DataSize = data_len / 2;
|
|
|
|
|
|
|
|
//JZSDK_LOG_DEBUG("data_len:%d u16DataSize:%d", data_len / 2, FIRST_HEIGHT * FIRST_WIDTH);
|
|
|
|
|
|
|
|
//合成像素，u8转换合并成u16
|
|
|
|
JZsdk_Merge_U8_to_U16_byReverse(data, data_len, u16Data, &u16DataSize);
|
|
|
|
|
|
|
|
//将灰度图数据转换为原始码流数据
|
|
|
|
unsigned char *raw_data = NULL;
|
|
|
|
int raw_data_len = 0;
|
|
|
|
|
|
|
|
//将原始码流数据转换为rgb数据
|
|
|
|
IRC_FrameDeal(u16Data, u16DataSize, &raw_data, &raw_data_len);
|
|
|
|
|
|
|
|
//获取放大的倍数
|
|
|
|
//光学数据缩放
|
|
|
|
int resize = JZ_FLAGCODE_OFF;
|
|
|
|
Camera_param(JZ_FLAGCODE_GET, CAMERA_RESIZE, &resize);
|
|
|
|
|
|
|
|
//将size转化为倍数
|
|
|
|
int ZoomRatio = 0;
|
|
|
|
switch (resize)
|
|
|
|
{
|
|
|
|
case 0:
|
|
|
|
ZoomRatio = JZ_FLAGCODE_OFF;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 1:
|
|
|
|
ZoomRatio = 2;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 2:
|
|
|
|
ZoomRatio = 4;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 3:
|
|
|
|
//红外做不了8倍放大咧
|
|
|
|
ZoomRatio = 4;
|
|
|
|
//ZoomRatio = 8;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
ZoomRatio = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ZoomRatio != JZ_FLAGCODE_OFF)
|
|
|
|
{
|
|
|
|
JZC1_RgaDeal(g_C1_RgaIrcInfo, ZoomRatio, raw_data, &raw_data_len);
|
|
|
|
}
|
|
|
|
|
|
|
|
//将数据放入混合缓冲区
|
|
|
|
if (g_MixedIrc_Buffer != NULL)
|
|
|
|
{
|
|
|
|
memcpy(g_MixedIrc_Buffer, raw_data, raw_data_len);
|
|
|
|
}
|
|
|
|
|
|
|
|
//将原始码流数据写入到编码器 并转换为h264
|
|
|
|
unsigned char *h264Data = NULL;
|
|
|
|
unsigned int h264DataLen = 0;
|
|
|
|
|
|
|
|
#ifdef RTK_MPP_STATUS_ON
|
|
|
|
MppPacket Packet = NULL;
|
|
|
|
|
|
|
|
RTK_mmp_enc_data_to_h264(JZsdk_RtkMmpGetEncHandleAddr(0), raw_data, raw_data_len, &Packet);
|
|
|
|
|
|
|
|
h264DataLen = mpp_packet_get_length(Packet);
|
|
|
|
h264Data = (unsigned char *)mpp_packet_get_pos(Packet);
|
|
|
|
//EncCfg->Packet_eos = mpp_packet_get_eos(packet);
|
|
|
|
// printf("获取到编码内容 len:%d\n",packet_len);
|
|
|
|
|
|
|
|
//释放掉packet
|
|
|
|
mpp_packet_deinit(&Packet);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
//将h264数据推送
|
|
|
|
JZC1_PushFrame(1, h264Data, h264DataLen);
|
|
|
|
|
|
|
|
//释放内存
|
|
|
|
if (raw_data != NULL)
|
|
|
|
{
|
|
|
|
free(raw_data);
|
|
|
|
raw_data = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (u16Data != NULL)
|
|
|
|
{
|
|
|
|
free(u16Data);
|
|
|
|
u16Data = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *JZC1_IrcDataBuffer_Thread(void *args)
|
|
|
|
{
|
|
|
|
|
|
|
|
struct timespec now;
|
|
|
|
|
|
|
|
//获取起始时间
|
|
|
|
struct timespec start_time;
|
|
|
|
clock_gettime(CLOCK_MONOTONIC, &start_time);
|
|
|
|
long long prev_time = start_time.tv_sec * NSEC_PER_SEC + start_time.tv_nsec;
|
|
|
|
|
|
|
|
//设置间隔时间
|
|
|
|
long long period = NSEC_PER_SEC / TARGET_FPS;
|
|
|
|
|
|
|
|
unsigned char *TempBuffer = (unsigned char *)malloc(163840);
|
|
|
|
unsigned int TempBufferLen = 0;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
while (1)
|
|
|
|
{
|
|
|
|
//获取当前时间
|
|
|
|
clock_gettime(CLOCK_MONOTONIC, &now);
|
|
|
|
long long current_time = now.tv_sec * NSEC_PER_SEC + now.tv_nsec;
|
|
|
|
|
|
|
|
//计算时间差
|
|
|
|
long long elapsed_time = current_time - prev_time;
|
|
|
|
|
|
|
|
//超过33ms
|
|
|
|
if (elapsed_time >= period)
|
|
|
|
{
|
|
|
|
while (FrameBuffer_UseFlag == JZ_FLAGCODE_ON)
|
|
|
|
{
|
|
|
|
delayUs(100);
|
|
|
|
}
|
|
|
|
|
|
|
|
FrameBuffer_UseFlag = JZ_FLAGCODE_ON;
|
|
|
|
|
|
|
|
memset(TempBuffer, 0, sizeof(TempBuffer));
|
|
|
|
memcpy(TempBuffer, FrameBuffer, FrameBufferLen);
|
|
|
|
TempBufferLen = FrameBufferLen;
|
|
|
|
|
|
|
|
FrameBuffer_UseFlag = JZ_FLAGCODE_OFF;
|
|
|
|
|
|
|
|
//红外数据缓冲线程
|
|
|
|
JZC1_IrcDeal(TempBuffer, TempBufferLen);
|
|
|
|
|
|
|
|
prev_time = current_time;
|
|
|
|
}
|
|
|
|
|
|
|
|
// 为了防止过于频繁地调用 clock_gettime，可以添加一个小的睡眠时间
|
|
|
|
// 例如，休眠1毫秒（100000000纳秒），以减少CPU占用
|
|
|
|
struct timespec req = { .tv_sec = 0, .tv_nsec = 1000000 };
|
|
|
|
nanosleep(&req, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
static T_JZsdkReturnCode JZC1_IrcDataSave(unsigned char *data, unsigned int data_len)
|
|
|
|
{
|
|
|
|
//避免缓冲区被同时操作
|
|
|
|
while (FrameBuffer_UseFlag == JZ_FLAGCODE_ON)
|
|
|
|
{
|
|
|
|
delayUs(100);
|
|
|
|
}
|
|
|
|
|
|
|
|
FrameBuffer_UseFlag = JZ_FLAGCODE_ON;
|
|
|
|
|
|
|
|
memset(FrameBuffer, 0, sizeof(FrameBuffer));
|
|
|
|
memcpy(FrameBuffer, data, data_len);
|
|
|
|
FrameBufferLen = data_len;
|
|
|
|
|
|
|
|
FrameBuffer_UseFlag = JZ_FLAGCODE_OFF;
|
|
|
|
|
|
|
|
return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
//红外数据接收线程
|
|
|
|
static void *JZC1_IrcDataRecv_Thread(void *args)
|
|
|
|
{
|
|
|
|
int frame_len = FIRST_WIDTH *2* FIRST_HEIGHT; //163840
|
|
|
|
unsigned char buf[frame_len]; //usb数据缓冲区需要为512的倍数
|
|
|
|
unsigned char frameData[frame_len]; // 存储整帧数据的画面缓冲区
|
|
|
|
unsigned int lineNum = 0;
|
|
|
|
int frame = 0;
|
|
|
|
int frameDataLen = 0;//缓冲区的数据长度
|
|
|
|
|
|
|
|
/*****
|
|
|
|
*
|
|
|
|
* 数据格式说明
|
|
|
|
*
|
|
|
|
* 帧头 0xaa 0xbb 0x02 0x80 0x01 0x00 + 行数 如第一行0x00 0x01
|
|
|
|
* 数据包长度为 0x0280
|
|
|
|
* 数据包 一包的行数为256 0x0100
|
|
|
|
* 当前数据为第x行 x= 0x0001
|
|
|
|
* 两位数据为一个点
|
|
|
|
* 接着把前4个点的数据 用第五个点替换掉
|
|
|
|
* *****/
|
|
|
|
|
|
|
|
while (1)
|
|
|
|
{
|
|
|
|
int realLen;
|
|
|
|
memset(buf,0,sizeof(buf));
|
|
|
|
T_JZsdkReturnCode ret = JZsdk_HalUsbBulk_ReadData(&g_usb_index, buf, sizeof(buf), &realLen);
|
|
|
|
if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
|
|
|
|
{
|
|
|
|
// 处理读取错误
|
|
|
|
JZSDK_LOG_ERROR("读取错误");
|
|
|
|
continue;
|
|
|
|
//return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
|
|
|
|
}
|
|
|
|
if (realLen != 0)
|
|
|
|
{
|
|
|
|
//JZSDK_LOG_INFO("读取到%d 字节",realLen);
|
|
|
|
}
|
|
|
|
|
|
|
|
//寻找数据是否存在帧头
|
|
|
|
for (int i = 0; i < realLen; i++)
|
|
|
|
{
|
|
|
|
// 验证帧头
|
|
|
|
if (memcmp(buf+i, FRAME_HEADER, FRAME_HEADER_SIZE) != 0)
|
|
|
|
{
|
|
|
|
// 帧头不匹配，可能是噪声或错误的数据包
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**********************
|
|
|
|
*
|
|
|
|
* 方法一，将usb缓冲区调整大小 到超过640*256， 然后直接输出整段画面，避免重复复制，节省处理时间
|
|
|
|
*
|
|
|
|
* ******************************/
|
|
|
|
//如果查找到帧头
|
|
|
|
|
|
|
|
//查看是否是第0帧
|
|
|
|
if (frame == 0)
|
|
|
|
{
|
|
|
|
//重置掉画面缓冲区
|
|
|
|
memset(frameData,0,sizeof(frameData));
|
|
|
|
|
|
|
|
//将数据置于缓冲区
|
|
|
|
frameDataLen = (realLen-i);
|
|
|
|
memcpy( &frameData[0], buf + i, frameDataLen);
|
|
|
|
|
|
|
|
//让画面帧强跳到第一帧
|
|
|
|
frame = 1;
|
|
|
|
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
//如果是第一帧
|
|
|
|
if (frame == 1)
|
|
|
|
{
|
|
|
|
memcpy( &frameData[frameDataLen], buf, frame_len-frameDataLen );
|
|
|
|
|
|
|
|
JZC1_IrcDataSave(frameData, frame_len);
|
|
|
|
|
|
|
|
frame = 2;
|
|
|
|
frameDataLen = 0;
|
|
|
|
//memset(frameData,0,sizeof(frameData));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//如果不是第1帧，且上段数据小于一画面段，说明为数据被切割
|
|
|
|
if ( i<frame_len)
|
|
|
|
{
|
|
|
|
//则于前端残余数据拼接，并输出
|
|
|
|
if (frame%2==0 && (frame != 1) )
|
|
|
|
{
|
|
|
|
|
|
|
|
memcpy( &frameData[frame_len-i], buf, i);
|
|
|
|
//将未处理raw数据放入缓冲区
|
|
|
|
|
|
|
|
//JZSDK_LOG_INFO("写入1 %d %x", i, frameData[20]);
|
|
|
|
|
|
|
|
JZC1_IrcDataSave(frameData, frame_len);
|
|
|
|
//JZSDK_LOG_INFO("放入数据到缓冲区");
|
|
|
|
//memset(frameData,0,sizeof(frameData));
|
|
|
|
}
|
|
|
|
frame++;
|
|
|
|
}
|
|
|
|
|
|
|
|
//如果剩余长度超出一画数据，将画面数据整段输出
|
|
|
|
if ( (i + frame_len) < realLen)
|
|
|
|
{
|
|
|
|
if (frame%2==0)
|
|
|
|
{
|
|
|
|
//JZSDK_LOG_INFO("写入2");
|
|
|
|
|
|
|
|
memcpy( &frameData[0], buf, frame_len);
|
|
|
|
|
|
|
|
//将未处理raw数据放入缓冲区
|
|
|
|
JZC1_IrcDataSave(frameData, frame_len);
|
|
|
|
//JZSDK_LOG_INFO("放入数据到缓冲区");
|
|
|
|
}
|
|
|
|
frame++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
//JZSDK_LOG_INFO("i:%d, frame_len:%d realLen:%d frame:%d",i,frame_len,realLen,frame);
|
|
|
|
|
|
|
|
//如果剩余数据小于一画，存进画面缓冲区
|
|
|
|
//memset(frameData,0,sizeof(frameData));
|
|
|
|
memcpy(frameData, buf+i, (realLen-i));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//C1 红外相机数据的初始化
|
|
|
|
static T_JZsdkReturnCode JZsdk_JZC1_Irc_Data_Init()
|
|
|
|
{
|
|
|
|
T_JZsdkReturnCode ret;
|
|
|
|
|
|
|
|
//初始化接收的usb口
|
|
|
|
ret = JZsdk_HalUsbBulk_Init(&g_usb_index, 0, 0, LINUX_USB_PID, LINUX_USB_VID, USB_IN_POINT, USB_OUT_POINT);
|
|
|
|
if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
|
|
|
|
{
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
//初始化usb接收线程
|
|
|
|
pthread_t ReadDataTask;
|
|
|
|
pthread_attr_t task_attribute; //线程属性
|
|
|
|
pthread_attr_init(&task_attribute); //初始化线程属性
|
|
|
|
pthread_attr_setdetachstate(&task_attribute, PTHREAD_CREATE_DETACHED); //设置线程分离属性
|
|
|
|
int Urcdata_Protection = pthread_create(&ReadDataTask,&task_attribute,JZC1_IrcDataRecv_Thread,NULL); //线程
|
|
|
|
if(Urcdata_Protection != 0)
|
|
|
|
{
|
|
|
|
JZSDK_LOG_ERROR("创建视频usb线程失败！");
|
|
|
|
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
//初始化送usb数据去处理的线程
|
|
|
|
pthread_t BufferDataTask;
|
|
|
|
pthread_attr_t BufferDataTask_attribute; //线程属性
|
|
|
|
pthread_attr_init(&BufferDataTask_attribute); //初始化线程属性
|
|
|
|
pthread_attr_setdetachstate(&BufferDataTask_attribute, PTHREAD_CREATE_DETACHED); //设置线程分离属性
|
|
|
|
int bufferdata_Protection = pthread_create(&BufferDataTask,&BufferDataTask_attribute,JZC1_IrcDataBuffer_Thread,NULL); //线程
|
|
|
|
if(bufferdata_Protection != 0)
|
|
|
|
{
|
|
|
|
JZSDK_LOG_ERROR("创建usb缓冲失败!");
|
|
|
|
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/********************
|
|
|
|
*
|
|
|
|
* 混合视频说明
|
|
|
|
*
|
|
|
|
* 1920*1088 做处理 并输出为 1920*1080
|
|
|
|
* __________________________________________________________________
|
|
|
|
* |_________________________________ |
|
|
|
|
* | |________________________________|
|
|
|
|
* | | |
|
|
|
|
* | | 1920*1088 /2 960* 544 |
|
|
|
|
* | | |
|
|
|
|
* | 320*256 拉伸4到 1280*1024 | |
|
|
|
|
* | 裁剪出 3/4 到 960 * 768 | |
|
|
|
|
* | | |
|
|
|
|
* | |________________________________|
|
|
|
|
* |_________________________________| |
|
|
|
|
* |__________________________________________________________________|
|
|
|
|
*
|
|
|
|
* ******************/
|
|
|
|
|
|
|
|
|
|
|
|
/******************
|
|
|
|
*
|
|
|
|
* 混合视频处理
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* ********************/
|
|
|
|
static void JZC1_MixedVideo_Deal()
|
|
|
|
{
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void *MixedVideo_Thread(void *args)
|
|
|
|
{
|
|
|
|
#ifdef RTK_RGA_STATUS_ON
|
|
|
|
struct timespec now;
|
|
|
|
int d_ret = 0;
|
|
|
|
|
|
|
|
//获取起始时间
|
|
|
|
struct timespec start_time;
|
|
|
|
clock_gettime(CLOCK_MONOTONIC, &start_time);
|
|
|
|
long long prev_time = start_time.tv_sec * NSEC_PER_SEC + start_time.tv_nsec;
|
|
|
|
|
|
|
|
//设置间隔时间
|
|
|
|
long long period = NSEC_PER_SEC / TARGET_FPS;
|
|
|
|
|
|
|
|
/***** 红外图像参数 **********************************************************************************************************/
|
|
|
|
|
|
|
|
//红外源图像
|
|
|
|
im_rect Irc_Rect;
|
|
|
|
Irc_Rect.x = 0;
|
|
|
|
Irc_Rect.y = 0;
|
|
|
|
Irc_Rect.width = JZ_ALIGN(FIRST_WIDTH, 16);
|
|
|
|
Irc_Rect.height = JZ_ALIGN(FIRST_HEIGHT, 16);
|
|
|
|
int IRc_Format = RK_FORMAT_YCbCr_420_SP;
|
|
|
|
|
|
|
|
//红外放大图像
|
|
|
|
im_rect Irc_ResizeRect;
|
|
|
|
Irc_ResizeRect.x = 0;
|
|
|
|
Irc_ResizeRect.y = 0;
|
|
|
|
Irc_ResizeRect.width = JZ_ALIGN(FIRST_WIDTH, 16) * 4;
|
|
|
|
Irc_ResizeRect.height = JZ_ALIGN(FIRST_HEIGHT, 16) * 4;
|
|
|
|
|
|
|
|
//红外裁剪区域
|
|
|
|
im_rect Irc_CropRect;
|
|
|
|
Irc_CropRect.width = Irc_ResizeRect.width / 4 * 3;
|
|
|
|
Irc_CropRect.height = Irc_ResizeRect.height / 4 * 3;
|
|
|
|
Irc_CropRect.x = (Irc_ResizeRect.width - Irc_CropRect.width)/2;
|
|
|
|
Irc_CropRect.y = (Irc_ResizeRect.height - Irc_CropRect.height)/2;
|
|
|
|
|
|
|
|
//红外源图像
|
|
|
|
RK_RgaImage *Irc_SrcImg = NULL;
|
|
|
|
RK_Rga_ImageInit(&Irc_SrcImg, Irc_Rect.width, Irc_Rect.height, IRc_Format, Irc_Rect.x, Irc_Rect.y, Irc_Rect.width, Irc_Rect.height);
|
|
|
|
|
|
|
|
//红外放大图像
|
|
|
|
RK_RgaImage *Irc_ResizeImg = NULL;
|
|
|
|
RK_Rga_ImageInit(&Irc_ResizeImg, Irc_ResizeRect.width, Irc_ResizeRect.height, IRc_Format, Irc_ResizeRect.x, Irc_ResizeRect.y, Irc_ResizeRect.width, Irc_ResizeRect.height);
|
|
|
|
|
|
|
|
//红外裁剪图像
|
|
|
|
RK_RgaImage *Irc_CropImg = NULL;
|
|
|
|
RK_Rga_ImageInit(&Irc_CropImg, Irc_CropRect.width, Irc_CropRect.height, IRc_Format, 0, 0, Irc_CropRect.width, Irc_CropRect.height);
|
|
|
|
|
|
|
|
/***** 光学图像参数 **********************************************************************************************************/
|
|
|
|
|
|
|
|
//光学源图像
|
|
|
|
im_rect Opt_Rect;
|
|
|
|
Opt_Rect.x = 0;
|
|
|
|
Opt_Rect.y = 0;
|
|
|
|
Opt_Rect.width = JZ_ALIGN(SECOND_WIDTH, 16);
|
|
|
|
Opt_Rect.height = JZ_ALIGN(SECOND_HEIGHT, 16);
|
|
|
|
int Opt_Format = RK_FORMAT_YCbCr_420_SP;
|
|
|
|
|
|
|
|
//光学源缩小图像
|
|
|
|
im_rect Opt_ResizeRect;
|
|
|
|
Opt_ResizeRect.x = 0;
|
|
|
|
Opt_ResizeRect.y = 0;
|
|
|
|
Opt_ResizeRect.width = JZ_ALIGN(SECOND_WIDTH, 16) / 2;
|
|
|
|
Opt_ResizeRect.height = JZ_ALIGN(SECOND_HEIGHT, 16) / 2;
|
|
|
|
|
|
|
|
//光学源图像
|
|
|
|
RK_RgaImage *Opt_SrcImg = NULL;
|
|
|
|
RK_Rga_ImageInit(&Opt_SrcImg, Opt_Rect.width, Opt_Rect.height, Opt_Format, Opt_Rect.x, Opt_Rect.y, Opt_Rect.width, Opt_Rect.height);
|
|
|
|
|
|
|
|
//光学的缩小图像
|
|
|
|
RK_RgaImage *Opt_ResizeImg = NULL;
|
|
|
|
RK_Rga_ImageInit(&Opt_ResizeImg, Opt_ResizeRect.width, Opt_ResizeRect.height, Opt_Format, Opt_ResizeRect.x, Opt_ResizeRect.y, Opt_ResizeRect.width, Opt_ResizeRect.height);
|
|
|
|
|
|
|
|
|
|
|
|
/***** 目标图像参数 ***************************************************************************************************/
|
|
|
|
|
|
|
|
//目标图像的矩形
|
|
|
|
im_rect Dst_Rect;
|
|
|
|
Dst_Rect.x = 0;
|
|
|
|
Dst_Rect.y = 0;
|
|
|
|
Dst_Rect.width = JZ_ALIGN(SECOND_WIDTH, 16);
|
|
|
|
Dst_Rect.height = JZ_ALIGN(SECOND_HEIGHT, 16);
|
|
|
|
int Dst_Format = RK_FORMAT_YCbCr_420_SP;
|
|
|
|
|
|
|
|
//目标图像中光学图像的矩形
|
|
|
|
im_rect Dst_OptRect;
|
|
|
|
Dst_OptRect.x = Dst_Rect.width / 2;
|
|
|
|
Dst_OptRect.y = Dst_Rect.height / 4;
|
|
|
|
Dst_OptRect.width = Opt_ResizeRect.width;
|
|
|
|
Dst_OptRect.height = Opt_ResizeRect.height;
|
|
|
|
|
|
|
|
//目标图像中红外图像的矩形
|
|
|
|
im_rect Dst_IrcRect;
|
|
|
|
Dst_IrcRect.x = 0;
|
|
|
|
Dst_IrcRect.y = (Dst_Rect.height - Irc_CropRect.height) / 2;
|
|
|
|
Dst_IrcRect.width = Irc_CropRect.width;
|
|
|
|
Dst_IrcRect.height = Irc_CropRect.height;
|
|
|
|
|
|
|
|
//目标图像
|
|
|
|
RK_RgaImage *DstImg = NULL;
|
|
|
|
RK_Rga_ImageInit(&DstImg, Dst_Rect.width, Dst_Rect.height, Dst_Format, Dst_Rect.x, Dst_Rect.y, Dst_Rect.width, Dst_Rect.height);
|
|
|
|
JZSDK_LOG_DEBUG("Dstimg witdh :%d height:%d DstImg->buf_size:%d", DstImg->width, DstImg->height, DstImg->buf_size);
|
|
|
|
|
|
|
|
//空缓冲区
|
|
|
|
rga_buffer_t EmptyImg = {0};
|
|
|
|
im_rect EmptyRect = {0};
|
|
|
|
|
|
|
|
//开始绘制画面，待优化，如多步骤合成为一个步骤
|
|
|
|
while (1)
|
|
|
|
{
|
|
|
|
//获取当前时间
|
|
|
|
clock_gettime(CLOCK_MONOTONIC, &now);
|
|
|
|
long long current_time = now.tv_sec * NSEC_PER_SEC + now.tv_nsec;
|
|
|
|
|
|
|
|
//计算时间差
|
|
|
|
long long elapsed_time = current_time - prev_time;
|
|
|
|
|
|
|
|
//超过33ms
|
|
|
|
if (elapsed_time >= period)
|
|
|
|
{
|
|
|
|
if (g_MixedIrc_Buffer == NULL || g_MixedOpt_Buffer == NULL)
|
|
|
|
{
|
|
|
|
delayMs(100);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
while (g_MixedOptBuffer_UseFlag == JZ_FLAGCODE_ON)
|
|
|
|
{
|
|
|
|
delayUs(100);
|
|
|
|
}
|
|
|
|
|
|
|
|
g_MixedOptBuffer_UseFlag = JZ_FLAGCODE_ON;
|
|
|
|
|
|
|
|
//填充输出图像
|
|
|
|
memset(DstImg->buf, 0x80, DstImg->buf_size);
|
|
|
|
|
|
|
|
//混合视频处理
|
|
|
|
memset(Irc_SrcImg->buf, 0, Irc_SrcImg->buf_size);
|
|
|
|
memset(Opt_SrcImg->buf, 0, Opt_SrcImg->buf_size);
|
|
|
|
|
|
|
|
//将数据放入缓冲区
|
|
|
|
memcpy(Irc_SrcImg->buf, g_MixedIrc_Buffer, (JZ_ALIGN(FIRST_WIDTH, 16)) * (JZ_ALIGN(FIRST_HEIGHT, 16)) * 3 / 2);
|
|
|
|
memcpy(Opt_SrcImg->buf, g_MixedOpt_Buffer, JZ_ALIGN(SECOND_WIDTH, 16) * JZ_ALIGN(SECOND_HEIGHT, 16) * 3 / 2);
|
|
|
|
|
|
|
|
g_MixedOptBuffer_UseFlag = JZ_FLAGCODE_OFF;
|
|
|
|
|
|
|
|
//光学数据处理
|
|
|
|
//缩小图像到1/2
|
|
|
|
d_ret = imresize(Opt_SrcImg->img, Opt_ResizeImg->img);
|
|
|
|
if (d_ret != IM_STATUS_SUCCESS)
|
|
|
|
{
|
|
|
|
printf("irc resize failed\n");
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
//红外数据处理
|
|
|
|
//放大图像到4倍
|
|
|
|
d_ret = imresize(Irc_SrcImg->img, Irc_ResizeImg->img);
|
|
|
|
if (d_ret != IM_STATUS_SUCCESS)
|
|
|
|
{
|
|
|
|
printf("opt resize failed\n");
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
//裁切红外图像
|
|
|
|
d_ret = imcrop(Irc_ResizeImg->img, Irc_CropImg->img, Irc_CropRect);
|
|
|
|
if (d_ret != IM_STATUS_SUCCESS)
|
|
|
|
{
|
|
|
|
printf("opt crop failed\n");
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
//将缩放好的光学画面放入目标画面
|
|
|
|
d_ret = improcess(Opt_ResizeImg->img, DstImg->img, EmptyImg, Opt_ResizeRect, Dst_OptRect, EmptyRect, IM_SYNC);
|
|
|
|
if (d_ret != IM_STATUS_SUCCESS)
|
|
|
|
{
|
|
|
|
printf("opt improcess failed\n");
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
//将裁切好的红外画面放入目标画面
|
|
|
|
d_ret = improcess(Irc_CropImg->img, DstImg->img, EmptyImg, Irc_CropImg->rect, Dst_IrcRect, EmptyRect, IM_SYNC);
|
|
|
|
if (d_ret != IM_STATUS_SUCCESS)
|
|
|
|
{
|
|
|
|
printf("irc improcess failed\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
//将原始码流数据写入到编码器 并转换为h264
|
|
|
|
unsigned char *h264Data = NULL;
|
|
|
|
unsigned int h264DataLen = 0;
|
|
|
|
|
|
|
|
//JZSDK_LOG_DEBUG("DstImg->buf_size:%d", DstImg->buf_size);
|
|
|
|
|
|
|
|
#ifdef RTK_MPP_STATUS_ON
|
|
|
|
MppPacket Packet = NULL;
|
|
|
|
|
|
|
|
RTK_mmp_enc_data_to_h264(JZsdk_RtkMmpGetEncHandleAddr(2), DstImg->buf, DstImg->buf_size, &Packet);
|
|
|
|
|
|
|
|
h264DataLen = mpp_packet_get_length(Packet);
|
|
|
|
h264Data = (unsigned char *)mpp_packet_get_pos(Packet);
|
|
|
|
//EncCfg->Packet_eos = mpp_packet_get_eos(packet);
|
|
|
|
// printf("获取到编码内容 len:%d\n",packet_len);
|
|
|
|
|
|
|
|
//释放掉packet
|
|
|
|
mpp_packet_deinit(&Packet);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
//推送视频流
|
|
|
|
JZC1_PushFrame(VIDEOMGMT_STREAMING_FLOW_INDEX_THIRD, h264Data, h264DataLen);
|
|
|
|
|
|
|
|
//JZSDK_LOG_DEBUG("混合一帧 :%d", h264DataLen);
|
|
|
|
|
|
|
|
//更新时间
|
|
|
|
prev_time = current_time;
|
|
|
|
}
|
|
|
|
|
|
|
|
// 为了防止过于频繁地调用 clock_gettime，可以添加一个小的睡眠时间
|
|
|
|
// 例如，休眠1毫秒（100000000纳秒），以减少CPU占用
|
|
|
|
struct timespec req = { .tv_sec = 0, .tv_nsec = 1000000 };
|
|
|
|
nanosleep(&req, NULL);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/******************
|
|
|
|
*
|
|
|
|
* 混合视频初始化
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* ********************/
|
|
|
|
static JZC1_MixedVideo_Init()
|
|
|
|
{
|
|
|
|
g_MixedIrc_Buffer = (unsigned char *)malloc(JZ_ALIGN(FIRST_WIDTH, 16)*JZ_ALIGN(FIRST_HEIGHT, 16)*3/2);
|
|
|
|
g_MixedOpt_Buffer = (unsigned char *)malloc(JZ_ALIGN(SECOND_WIDTH, 16)*JZ_ALIGN(SECOND_HEIGHT, 16)*3/2);
|
|
|
|
|
|
|
|
//混合视频初始化
|
|
|
|
pthread_t Task;
|
|
|
|
pthread_attr_t attribute; //线程属性
|
|
|
|
pthread_attr_init(&attribute); //初始化线程属性
|
|
|
|
pthread_attr_setdetachstate(&attribute, PTHREAD_CREATE_DETACHED); //设置线程分离属性
|
|
|
|
int bufferdata_Protection = pthread_create(&Task,&attribute,MixedVideo_Thread,NULL); //线程
|
|
|
|
if(bufferdata_Protection != 0)
|
|
|
|
{
|
|
|
|
JZSDK_LOG_ERROR("创建混合视频初始化失败!");
|
|
|
|
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
JZSDK_LOG_INFO("MixedVidoe_Init Success");
|
|
|
|
|
|
|
|
return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
//JZ_C1 的媒体初始化
|
|
|
|
static T_JZsdkReturnCode JZC1_MediaInit()
|
|
|
|
{
|
|
|
|
T_JZsdkReturnCode ret = JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
|
|
|
|
|
|
|
|
|
|
|
|
//初始化媒体模块
|
|
|
|
#ifdef MEDIA_PROC_CONFIG_STATUS_ON
|
|
|
|
|
|
|
|
//初始化videoMgmt模块
|
|
|
|
VideoMgmt_Init();
|
|
|
|
|
|
|
|
//初始化Mulit模块
|
|
|
|
#ifdef RTK_MPP_STATUS_ON
|
|
|
|
//初始化红外的编解码器
|
|
|
|
RTK_mmp_enc_Init(JZsdk_RtkMmpGetEncHandleAddr(0), MPP_VIDEO_CodingAVC, MPP_FMT_YUV420SP, FIRST_WIDTH, FIRST_HEIGHT, 30, 5);
|
|
|
|
|
|
|
|
//初始化光学的编解码器
|
|
|
|
RTK_mmp_dec_Init(JZsdk_RtkMmpGetDecHandleAddr(1), MPP_VIDEO_CodingMJPEG, MPP_FMT_YUV420SP, SECOND_WIDTH, SECOND_HEIGHT);
|
|
|
|
RTK_mmp_enc_Init(JZsdk_RtkMmpGetEncHandleAddr(1), MPP_VIDEO_CodingAVC, MPP_FMT_YUV420SP, SECOND_WIDTH, SECOND_HEIGHT, 30, 15);
|
|
|
|
|
|
|
|
// RTK_mmp_dec_Init(JZsdk_RtkMmpGetDecHandleAddr(1), MPP_VIDEO_CodingMJPEG, MPP_FMT_YUV420SP, SECOND_WIDTH, SECOND_HEIGHT);
|
|
|
|
// RTK_mmp_enc_Init(JZsdk_RtkMmpGetEncHandleAddr(1), MPP_VIDEO_CodingAVC, MPP_FMT_YUV420SP, SECOND_WIDTH, SECOND_HEIGHT, 30, 15);
|
|
|
|
|
|
|
|
//初始化混合视频流的编码器
|
|
|
|
RTK_mmp_enc_Init(JZsdk_RtkMmpGetEncHandleAddr(2), MPP_VIDEO_CodingAVC, MPP_FMT_YUV420SP, SECOND_WIDTH, SECOND_HEIGHT, 30, 15);
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
//初始化Camera模块
|
|
|
|
int CameraFd = -1;
|
|
|
|
ret = V4l2_Camarainit2(&CameraFd, SECOND_WIDTH, SECOND_HEIGHT, 30);
|
|
|
|
if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
|
|
|
|
{
|
|
|
|
JZSDK_LOG_ERROR("光学相机启动失败");
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
|
|
|
|
//光学相机的抓取
|
|
|
|
ret = JZsdk_FrameCatch_Single(JZC1_OptDeal);
|
|
|
|
}
|
|
|
|
|
|
|
|
//初始化IRC_funtion模块
|
|
|
|
ret = IRC_ParamInit(FIRST_HEIGHT, FIRST_WIDTH, 25);
|
|
|
|
if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
|
|
|
|
{
|
|
|
|
JZSDK_LOG_ERROR("初始化红外的数据处理失败");
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
//初始化红外的数据输入
|
|
|
|
ret = JZsdk_JZC1_Irc_Data_Init();
|
|
|
|
if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
|
|
|
|
{
|
|
|
|
JZSDK_LOG_ERROR("红外相机初始化失败");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//设置默认参数
|
|
|
|
|
|
|
|
//默认推送红外摄像头 后续改成 红外+光学 的组合画面
|
|
|
|
VideoMgmt_VideoStreamFlowIndex(VIDEOMGMT_STREAMING_FLOW_INDEX_THIRD);
|
|
|
|
|
|
|
|
//设置快门为开
|
|
|
|
JZsdk_Camera_ShutterSwitch(JZ_FLAGCODE_ON);
|
|
|
|
|
|
|
|
//设置伪彩颜色为hot
|
|
|
|
int value = 8;
|
|
|
|
Camera_param(JZ_FLAGCODE_SET, CAMERA_PSEUDO_COLOR, &value);
|
|
|
|
|
|
|
|
//设置为默认输出模式
|
|
|
|
value = 0;
|
|
|
|
Camera_param(JZ_FLAGCODE_SET, CAMERA_PIXEL_PSEUDO_COLOR_MODE, &value);
|
|
|
|
|
|
|
|
//设置默认打开自动校正
|
|
|
|
value = JZ_FLAGCODE_ON;
|
|
|
|
Proc_IRC_param(JZ_FLAGCODE_SET, JZSDK_WIDGET_BAD_PIXEL_CORRECT_MODE, &value);
|
|
|
|
|
|
|
|
//初始化变焦模块
|
|
|
|
Cam_Zoom_Init();
|
|
|
|
|
|
|
|
//初始化RGA模块
|
|
|
|
#ifdef RTK_RGA_STATUS_ON
|
|
|
|
ret = JZC1_RgaInit(&g_C1_RgaIrcInfo, JZ_ALIGN(FIRST_WIDTH, 16), JZ_ALIGN(FIRST_HEIGHT, 16), RK_FORMAT_YCbCr_420_SP);
|
|
|
|
ret = JZC1_RgaInit(&g_C1_RgaOptInfo, JZ_ALIGN(SECOND_WIDTH, 16), JZ_ALIGN(SECOND_HEIGHT, 16), RK_FORMAT_YCbCr_420_SP);
|
|
|
|
|
|
|
|
//混合视频初始化
|
|
|
|
JZC1_MixedVideo_Init();
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef RTK_RGA_STATUS_ON
|
|
|
|
|
|
|
|
static T_JZsdkReturnCode JZC1_RgaInit(C1_RgaInfo **rgaInfo, int dst_width, int dst_height, int dst_format)
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
|
|
//初始化rga结构体
|
|
|
|
(*rgaInfo) = (C1_RgaInfo *)malloc(sizeof(C1_RgaInfo));
|
|
|
|
if ((*rgaInfo) == NULL)
|
|
|
|
{
|
|
|
|
JZSDK_LOG_ERROR("RGA初始化失败");
|
|
|
|
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
int width = dst_width;
|
|
|
|
int height = dst_height;
|
|
|
|
int rect_x = 0;
|
|
|
|
int rect_y = 0;
|
|
|
|
int rect_w = dst_width;
|
|
|
|
int rect_h = dst_height;
|
|
|
|
|
|
|
|
|
|
|
|
(*rgaInfo)->src_img = NULL;
|
|
|
|
RK_Rga_ImageInit(&(*rgaInfo)->src_img, width, height, dst_format, rect_x, rect_y, rect_w, rect_h); //初始化输入模块
|
|
|
|
|
|
|
|
(*rgaInfo)->corp_img = NULL;
|
|
|
|
RK_Rga_ImageInit(&(*rgaInfo)->corp_img, width, height, dst_format, rect_x, rect_y, rect_w, rect_h); //初始化裁剪模块
|
|
|
|
|
|
|
|
(*rgaInfo)->dst_img = NULL;
|
|
|
|
RK_Rga_ImageInit(&(*rgaInfo)->dst_img, width, height, dst_format, rect_x, rect_y, rect_w, rect_h); //初始化输出模块
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
//rga处理
|
|
|
|
#ifdef RTK_RGA_STATUS_ON
|
|
|
|
static T_JZsdkReturnCode JZC1_RgaDeal(C1_RgaInfo *rga_info, int resize, unsigned char *image, unsigned int *imgage_size)
|
|
|
|
{
|
|
|
|
int d_ret;
|
|
|
|
|
|
|
|
|
|
|
|
if (g_C1_RgaIrcInfo == NULL || *imgage_size != rga_info->src_img->buf_size)
|
|
|
|
{
|
|
|
|
printf("C1_Rga_Deal failed imagesize:%d bufsize:%d\n", *imgage_size, rga_info->src_img->buf_size);
|
|
|
|
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
//检查裁剪倍数是否改变
|
|
|
|
if (resize != rga_info->scale)
|
|
|
|
{
|
|
|
|
rga_info->scale = resize;
|
|
|
|
|
|
|
|
//释放裁剪区域, 并重新注册
|
|
|
|
if (rga_info->corp_img != NULL)
|
|
|
|
{
|
|
|
|
RK_Rga_ImageDeInit(&(rga_info->corp_img));
|
|
|
|
|
|
|
|
int width = rga_info->src_img->width / resize;
|
|
|
|
int height = rga_info->src_img->height / resize;
|
|
|
|
int rect_x = (rga_info->src_img->width) / 2 - width / 2;
|
|
|
|
int rect_y = (rga_info->src_img->height) / 2 - height / 2;
|
|
|
|
int rect_w = width;
|
|
|
|
int rect_h = height;
|
|
|
|
int dst_format = rga_info->src_img->format;
|
|
|
|
|
|
|
|
RK_Rga_ImageInit(&(rga_info->corp_img), width, height, dst_format, rect_x, rect_y, rect_w, rect_h); //初始化裁剪模块
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//将图像放入处理器
|
|
|
|
memcpy(rga_info->src_img->buf, image, *imgage_size);
|
|
|
|
|
|
|
|
//JZSDK_LOG_DEBUG("裁剪倍率%d",resize);
|
|
|
|
|
|
|
|
if (resize == 0)
|
|
|
|
{
|
|
|
|
return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
//裁剪图像
|
|
|
|
d_ret = imcrop(rga_info->src_img->img, rga_info->corp_img->img, rga_info->corp_img->rect);
|
|
|
|
if (d_ret != IM_STATUS_SUCCESS)
|
|
|
|
{
|
|
|
|
printf("crop failed resize:%d\n",resize);
|
|
|
|
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
//缩放图像
|
|
|
|
d_ret = imresize(rga_info->corp_img->img, rga_info->dst_img->img);
|
|
|
|
if (d_ret != IM_STATUS_SUCCESS)
|
|
|
|
{
|
|
|
|
printf("resize failed\n");
|
|
|
|
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
//返回图像
|
|
|
|
memcpy(image, rga_info->dst_img->buf, rga_info->dst_img->buf_size);
|
|
|
|
//printf("image[0]:%d image[1]:%d\n", image[0], image[1]);
|
|
|
|
*imgage_size = rga_info->dst_img->buf_size;
|
|
|
|
|
|
|
|
return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
|
|
|
|
|
|
|
|
|
|
|
|
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
T_JZsdkReturnCode JZC1_Init()
|
|
|
|
{
|
|
|
|
T_JZsdkReturnCode ret;
|
|
|
|
|
|
|
|
//初始化引脚
|
|
|
|
Ircut_Init();
|
|
|
|
|
|
|
|
//初始化媒体模块
|
|
|
|
ret = JZC1_MediaInit();
|
|
|
|
|
|
|
|
JZSDK_LOG_INFO("JZ_C1 INIT COMPLETED\n");
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
...
|
...
|
|
