潘浩彬 / JZSDK_Linux · 提交

转到一个项目

作者 ookk303
提交 0bb32c7f2542f2ec095fc4b94daf46f4e6ca9b25 1 个父辈 7f1bda50

210更新

内嵌 并排对比
正在显示 25 个修改的文件 包含 748 行增加 和 664 行删除
@@ -57,7 +57,13 @@ @@ -57,7 +57,13 @@
57 "videostream_push.h": "c", 57 "videostream_push.h": "c",
58 "v4l2_record.h": "c", 58 "v4l2_record.h": "c",
59 "deviceinfo.h": "c", 59 "deviceinfo.h": "c",
60 - "mediaproc.h": "c" 60 + "mediaproc.h": "c",
  61 + "jzsdk_network.h": "c",
  62 + "kt_irc.h": "c",
  63 + "rtk_mmp_dec.h": "c",
  64 + "rtk_mmp_enc.h": "c",
  65 + "videostreamtranscode.h": "c",
  66 + "time.h": "c"
61 }, 67 },
62 "Codegeex.GenerationPreference": "automatic", 68 "Codegeex.GenerationPreference": "automatic",
63 "C_Cpp.dimInactiveRegions": false 69 "C_Cpp.dimInactiveRegions": false
1 # 编译链的配置 1 # 编译链的配置
2 2
3 #1、编译链与设备类型的选择 3 #1、编译链与设备类型的选择
4 -set(DEVICE_NAME JZ_H150S) 4 +set(DEVICE_NAME JZ_C1)
5 #上一行为禁止修改行 5 #上一行为禁止修改行
6 6
7 message("**************************JZSDK构建编译开始***************************\n") 7 message("**************************JZSDK构建编译开始***************************\n")
@@ -40,6 +40,13 @@ if(${DEVICE_INFO_MODULE} STREQUAL "VERSION_SWITCH_ON") @@ -40,6 +40,13 @@ if(${DEVICE_INFO_MODULE} STREQUAL "VERSION_SWITCH_ON")
40 40
41 endif() 41 endif()
42 42
  43 +#如果要加载设备配置
  44 +if(${DEVICE_CONFIG_MODULE} STREQUAL "VERSION_SWITCH_ON")
  45 + message("\n设备配置源码加载中")
  46 + file(GLOB_RECURSE DEVICE_CONFOG_SRC ${ROOT_DIRS}Module/DeviceConfig/*.c)
  47 + list(APPEND ALL_SRC_FILES ${DEVICE_CONFOG_SRC})
  48 +endif()
  49 +
43 #如果要加载云台模块，需要加载以下附属内容 50 #如果要加载云台模块，需要加载以下附属内容
44 if(${GIMBAL_MODULE} STREQUAL "VERSION_SWITCH_ON") 51 if(${GIMBAL_MODULE} STREQUAL "VERSION_SWITCH_ON")
45 message("\n云台模块源码加载中") 52 message("\n云台模块源码加载中")
@@ -9,6 +9,9 @@ set(AUDIODEAL_MODULE VERSION_SWITCH_OFF) @@ -9,6 +9,9 @@ set(AUDIODEAL_MODULE VERSION_SWITCH_OFF)
9 # 信息模块 9 # 信息模块
10 set(DEVICE_INFO_MODULE VERSION_SWITCH_OFF) 10 set(DEVICE_INFO_MODULE VERSION_SWITCH_OFF)
11 11
  12 +# 设备配置模块
  13 +set(DEVICE_CONFIG_MODULE VERSION_SWITCH_OFF)
  14 +
12 # Gimbal 云台处理模块 15 # Gimbal 云台处理模块
13 set(GIMBAL_MODULE VERSION_SWITCH_OFF) 16 set(GIMBAL_MODULE VERSION_SWITCH_OFF)
14 17
@@ -57,12 +60,16 @@ set(IMAGEPROCESSING_MODULE VERSION_SWITCH_OFF) @@ -57,12 +60,16 @@ set(IMAGEPROCESSING_MODULE VERSION_SWITCH_OFF)
57 # 添加信息模块 60 # 添加信息模块
58 set(DEVICE_INFO_MODULE VERSION_SWITCH_ON) 61 set(DEVICE_INFO_MODULE VERSION_SWITCH_ON)
59 62
  63 +# 添加设备配置模块
  64 +set(DEVICE_CONFIG_MODULE VERSION_SWITCH_ON)
  65 +
60 # 添加UI管理模块 66 # 添加UI管理模块
61 set(UI_CONTROL_MODULE VERSION_SWITCH_ON) 67 set(UI_CONTROL_MODULE VERSION_SWITCH_ON)
62 68
63 # 添加电源管理模块 69 # 添加电源管理模块
64 set(POWER_MANAGER_MODULE VERSION_SWITCH_ON) 70 set(POWER_MANAGER_MODULE VERSION_SWITCH_ON)
65 71
  72 +
66 message("通用库加载完成") 73 message("通用库加载完成")
67 74
68 ########################### 独立库加载 ########################################## 75 ########################### 独立库加载 ##########################################
@@ -22,6 +22,7 @@ @@ -22,6 +22,7 @@
22 #include "JZsdk_haldata_deal/JZsdk_data_transmisson.h" 22 #include "JZsdk_haldata_deal/JZsdk_data_transmisson.h"
23 #include "MediaProc/MediaProc.h" 23 #include "MediaProc/MediaProc.h"
24 #include "UI_control/WidegMgmt/JZsdk_Widget.h" 24 #include "UI_control/WidegMgmt/JZsdk_Widget.h"
  25 +#include "DeviceConfig/DeviceConfig.h"
25 26
26 #if APP_VERSION == APP_PSDK 27 #if APP_VERSION == APP_PSDK
27 #include "fc_subscription/test_fc_subscription.h" 28 #include "fc_subscription/test_fc_subscription.h"
@@ -347,11 +348,8 @@ T_JZsdkReturnCode Main_APP_Psdk() @@ -347,11 +348,8 @@ T_JZsdkReturnCode Main_APP_Psdk()
347 348
348 else if (DEVICE_VERSION == JZ_C1) 349 else if (DEVICE_VERSION == JZ_C1)
349 { 350 {
350 - //引脚初始化  
351 - Ircut_Init();  
352 -  
353 - //视频流模块初始化  
354 - MediaProc_Init(); 351 + //初始化C1
  352 + JZC1_Init();
355 } 353 }
356 354
357 355
@@ -7,19 +7,19 @@ @@ -7,19 +7,19 @@
7 #define VERSION_CHOOSE_H 7 #define VERSION_CHOOSE_H
8 #include "./ConfigParams.h" 8 #include "./ConfigParams.h"
9 //1~10行 除了D可以修改版本选择 禁止动任何东西 9 //1~10行 除了D可以修改版本选择 禁止动任何东西
10 -#define DEVICE_VERSION JZ_H150S 10 +#define DEVICE_VERSION JZ_C1
11 11
12 //禁止修改行 选择是串口程序 还是 psdk程序 12 //禁止修改行 选择是串口程序 还是 psdk程序
13 #define APP_VERSION APP_PSDK 13 #define APP_VERSION APP_PSDK
14 14
15 //禁止修改行 板子型号 15 //禁止修改行 板子型号
16 -#define PLATFORM_VERSION PLATFORM_H3 16 +#define PLATFORM_VERSION PLATFORM_V3S
17 17
18 //禁止修改行 串口连接程序的软件版本号 18 //禁止修改行 串口连接程序的软件版本号
19 #define MAJOR_VERSION 0x01 19 #define MAJOR_VERSION 0x01
20 #define MINOR_VERSION 0x03 20 #define MINOR_VERSION 0x03
21 #define MODIFY_VERSION 0x09 21 #define MODIFY_VERSION 0x09
22 -#define DEBUG_VERSION 0x02 22 +#define DEBUG_VERSION 0x05
23 23
24 //禁止修改行 滤波方式 24 //禁止修改行 滤波方式
25 #define FILTERING_TYPE HIGH_PASS_FILTERING 25 #define FILTERING_TYPE HIGH_PASS_FILTERING
@@ -48,6 +48,7 @@ @@ -48,6 +48,7 @@
48 //是否开启媒体功能 48 //是否开启媒体功能
49 #ifdef MACRO_MEDIA_PROC_MODULE 49 #ifdef MACRO_MEDIA_PROC_MODULE
50 #define MEDIA_PROC_CONFIG_STATUS VERSION_SWITCH_ON 50 #define MEDIA_PROC_CONFIG_STATUS VERSION_SWITCH_ON
  51 + #define MEDIA_PROC_CONFIG_STATUS_ON
51 #else 52 #else
52 #define MEDIA_PROC_CONFIG_STATUS VERSION_SWITCH_OFF 53 #define MEDIA_PROC_CONFIG_STATUS VERSION_SWITCH_OFF
53 #endif 54 #endif
@@ -103,6 +104,7 @@ @@ -103,6 +104,7 @@
103 104
104 //是否开启媒体管理功能 105 //是否开启媒体管理功能
105 #define MEDIA_PROC_CONFIG_STATUS VERSION_SWITCH_ON 106 #define MEDIA_PROC_CONFIG_STATUS VERSION_SWITCH_ON
  107 + #define MEDIA_PROC_CONFIG_STATUS_ON
106 108
107 //是否开启红外相机功能 109 //是否开启红外相机功能
108 #define IRC_CONFIG_STATUS VERSION_SWITCH_ON 110 #define IRC_CONFIG_STATUS VERSION_SWITCH_ON
1 /** 1 /**
2 ******************************************************************** 2 ********************************************************************
3 - * @file Kt_Irc.h  
4 - * Kt_Irc的头文件 3 + * @file DeviceConfig.h
  4 + * DeviceConfig.h的头文件
5 * 5 *
6 ********************************************************************* 6 *********************************************************************
7 */ 7 */
8 8
9 /* Define to prevent recursive inclusion 避免重定义 -------------------------------------*/ 9 /* Define to prevent recursive inclusion 避免重定义 -------------------------------------*/
10 -#ifndef KT_IRC_H  
11 -#define KT_IRC_H 10 +#ifndef DEVICE_CONFIG_H
  11 +#define DEVICE_CONFIG_H
12 12
13 -/* Includes ------------------------------------------------------------------*/  
14 #include "JZsdk_Base/JZsdk_Code/JZsdk_Code.h" 13 #include "JZsdk_Base/JZsdk_Code/JZsdk_Code.h"
15 14
  15 +#include "DeviceConfig/JZC1/JZC1.h"
  16 +
  17 +
  18 +/* Includes ------------------------------------------------------------------*/
16 #ifdef __cplusplus 19 #ifdef __cplusplus
17 extern "C" { 20 extern "C" {
18 #endif 21 #endif
19 22
  23 +
  24 +
20 /* Exported constants --------------------------------------------------------*/ 25 /* Exported constants --------------------------------------------------------*/
21 /* 常亮定义*/ 26 /* 常亮定义*/
22 27
23 -  
24 /* Exported types ------------------------------------------------------------*/ 28 /* Exported types ------------------------------------------------------------*/
25 29
26 -/* Exported functions --------------------------------------------------------*/  
27 -T_JZsdkReturnCode JZsdk_Kt_Irc_Camera_Init();  
28 -T_JZsdkReturnCode JZsdk_Kt_Irc_ShutterSwitch(int value);  
29 -  
30 30
31 #ifdef __cplusplus 31 #ifdef __cplusplus
32 } 32 }
  1 +
  2 +#include <stdio.h>
  3 +#include <stdlib.h>
  4 +#include <string.h>
  5 +#include <pthread.h>
  6 +
  7 +
  8 +#include "JZsdkLib.h"
  9 +#include "BaseConfig.h"
  10 +#include "JZsdk_usb_bulk/JZsdk_usb_bulk.h"
  11 +
  12 +#include "IRCUT/ircut.h"
  13 +
  14 +
  15 +#ifdef RTK_MPP_STATUS_ON
  16 +
  17 +#include "MediaProc/MultProc/RTK_mmp/RTK_mmp.h"
  18 +#include "MediaProc/Camera/Cam_FrameCatch/Cam_FrameCatch.h"
  19 +#include "MediaProc/MediaParm.h"
  20 +#include "MediaProc/MultProc/RTK_mmp/Dec/RTK_mmp_dec.h"
  21 +#include "MediaProc/MultProc/RTK_mmp/Enc/RTK_mmp_enc.h"
  22 +#include "MediaProc/VideoMgmt/VideoStreamPush/VideoStream_Push.h"
  23 +#include "MediaProc/VideoMgmt/VideoMgmt.h"
  24 +#include "MediaProc/IRC_funtion/IRC_Param.h"
  25 +#include "MediaProc/IRC_funtion/IRC_funtion.h"
  26 +#include "MediaProc/MediaProc_Param.h"
  27 +
  28 +#endif
  29 +
  30 +static void *g_usb_index = NULL;
  31 +
  32 +// 定义 昆腾的 帧头长度和帧头内容
  33 +#define FRAME_HEADER_SIZE 4
  34 +static const unsigned char FRAME_HEADER[FRAME_HEADER_SIZE] = {0xaa, 0xbb, 0xcc, 0xdd};
  35 +
  36 +
  37 +//数据推送函数
  38 +static T_JZsdkReturnCode JZC1_PushFrame(int CameraIndex, unsigned char* data, unsigned int data_len)
  39 +{
  40 + int currentIndex = VideoMgmt_GetVideoStreamFlowIndexNum(); //获取当前视频流索引
  41 + //无视频流
  42 + if (currentIndex == 0)
  43 + {
  44 + //不推送视频
  45 + return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
  46 + }
  47 +
  48 + //红外相机
  49 + if (currentIndex == 1 && CameraIndex == 1)
  50 + {
  51 + //推送数据到流转模块
  52 + VideoMgmt_Single_FrameIn(data, data_len);
  53 + }
  54 +
  55 + //光学相机
  56 + if(CameraIndex == 2 && currentIndex == 2)
  57 + {
  58 + //推送数据到流转模块
  59 + VideoMgmt_Single_FrameIn(data, data_len);
  60 + }
  61 +
  62 + return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
  63 +}
  64 +
  65 +
  66 +static T_JZsdkReturnCode JZC1_OptDeal(unsigned char *data, unsigned int data_len)
  67 +{
  68 + //JZSDK_LOG_INFO("JZC1_OptDeal");
  69 +
  70 +#ifdef RTK_MPP_STATUS_ON
  71 + MppFrame yuv_data = NULL; //用于传递yuv数据的地址
  72 + MppPacket Packet = NULL;
  73 +
  74 + //输入数据进入解码器
  75 + RTK_mmp_dec_input(JZsdk_RtkMmpGetDecHandleAddr(1), data, data_len, &yuv_data);
  76 +
  77 + // int width = mpp_frame_get_width(yuv_data);
  78 + // int height = mpp_frame_get_height(yuv_data);
  79 + // int h_stride = mpp_frame_get_hor_stride(yuv_data);
  80 + // int v_stride = mpp_frame_get_ver_stride(yuv_data);
  81 +
  82 + // JZSDK_LOG_INFO("w:%d h:%d hor:%d ver:%d",width,height,h_stride,v_stride);
  83 +
  84 + //将返回的数据输入进编码器
  85 + RTK_mmp_enc_yuv_to_h264_byFrame(JZsdk_RtkMmpGetEncHandleAddr(1), yuv_data, &Packet);
  86 +
  87 + //获取数据指针与长度
  88 + int packet_len = mpp_packet_get_length(Packet);
  89 + void *ptr = mpp_packet_get_pos(Packet);
  90 +
  91 + //推送视频流
  92 + JZC1_PushFrame(2, (unsigned char *)ptr, packet_len);
  93 +
  94 + //释放掉编码图像
  95 + mpp_packet_deinit(&Packet);
  96 +#endif
  97 +
  98 + return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
  99 +}
  100 +
  101 +//红外数据纠正函数, 暂定全部替换
  102 +static T_JZsdkReturnCode JZC1_Irc_DataCorrect(unsigned char *data)
  103 +{
  104 + //像素修正
  105 + data[0] = data[5];
  106 + data[1] = data[6];
  107 + data[2] = data[5];
  108 + data[3] = data[6];
  109 +}
  110 +
  111 +
  112 +//在这里将灰度图数据转换成目标数据
  113 +static T_JZsdkReturnCode JZC1_IrcDeal(unsigned char *data, unsigned int data_len)
  114 +{
  115 + //JZSDK_LOG_DEBUG("irc数据处理");
  116 +
  117 + //红外数据纠正处理
  118 + JZC1_Irc_DataCorrect(data);
  119 +
  120 + //将灰度图数据转换为原始码流数据
  121 + unsigned char *raw_data = NULL;
  122 + int raw_data_len = 0;
  123 + IRC_FrameDeal(data, data_len, &raw_data, &raw_data_len);
  124 +
  125 + //将原始码流数据写入到编码器 并转换为h264
  126 + unsigned char *h264Data = NULL;
  127 + unsigned int h264DataLen = 0;
  128 +
  129 +#ifdef RTK_MPP_STATUS_ON
  130 + MppPacket Packet = NULL;
  131 +
  132 + RTK_mmp_enc_data_to_h264(JZsdk_RtkMmpGetEncHandleAddr(0), raw_data, raw_data_len, &Packet);
  133 +
  134 + h264DataLen = mpp_packet_get_length(Packet);
  135 + h264Data = (unsigned char *)mpp_packet_get_pos(Packet);
  136 + //EncCfg->Packet_eos = mpp_packet_get_eos(packet);
  137 + // printf("获取到编码内容 len:%d\n",packet_len);
  138 +
  139 + //释放掉packet
  140 + mpp_packet_deinit(&Packet);
  141 +#endif
  142 +
  143 + //将h264数据推送
  144 + JZC1_PushFrame(1, h264Data, h264DataLen);
  145 +
  146 + //释放内存
  147 + if (raw_data != NULL)
  148 + {
  149 + free(raw_data);
  150 + raw_data = NULL;
  151 + }
  152 +
  153 + return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
  154 +}
  155 +
  156 +//红外数据接收线程
  157 +static void *JZC1_IrcDataRecv_Thread(void *args)
  158 +{
  159 + int frame_len = FIRST_WIDTH *2* FIRST_HEIGHT; //163840
  160 + unsigned char buf[frame_len]; //usb数据缓冲区需要为512的倍数
  161 + unsigned char frameData[frame_len]; // 存储整帧数据的画面缓冲区
  162 + unsigned int lineNum = 0;
  163 + int frame = 0;
  164 + int frameDataLen = 0;//缓冲区的数据长度
  165 +
  166 + /*****
  167 + *
  168 + * 数据格式说明
  169 + *
  170 + * 帧头 0xaa 0xbb 0x02 0x80 0x01 0x00 + 行数 如第一行0x00 0x01
  171 + * 数据包长度为 0x0280
  172 + * 数据包 一包的行数为256 0x0100
  173 + * 当前数据为第x行 x= 0x0001
  174 + * 两位数据为一个点
  175 + * 接着把前4个点的数据 用第五个点替换掉
  176 + * *****/
  177 +
  178 + while (1)
  179 + {
  180 + int realLen;
  181 + memset(buf,0,sizeof(buf));
  182 + T_JZsdkReturnCode ret = JZsdk_HalUsbBulk_ReadData(&g_usb_index, buf, sizeof(buf), &realLen);
  183 + if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
  184 + {
  185 + // 处理读取错误
  186 + JZSDK_LOG_ERROR("读取错误");
  187 + continue;
  188 + //return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
  189 + }
  190 + if (realLen != 0)
  191 + {
  192 + //JZSDK_LOG_INFO("读取到%d 字节",realLen);
  193 + }
  194 +
  195 + //寻找数据是否存在帧头
  196 + for (int i = 0; i < realLen; i++)
  197 + {
  198 + // 验证帧头
  199 + if (memcmp(buf+i, FRAME_HEADER, FRAME_HEADER_SIZE) != 0)
  200 + {
  201 + // 帧头不匹配，可能是噪声或错误的数据包
  202 + continue;
  203 + }
  204 +
  205 +/**********************
  206 + *
  207 + * 方法一，将usb缓冲区调整大小 到超过640*256， 然后直接输出整段画面，避免重复复制，节省处理时间
  208 + *
  209 + * ******************************/
  210 + //如果查找到帧头
  211 +
  212 + //查看是否是第0帧
  213 + if (frame == 0)
  214 + {
  215 + //重置掉画面缓冲区
  216 + memset(frameData,0,sizeof(frameData));
  217 +
  218 + //将数据置于缓冲区
  219 + frameDataLen = (realLen-i);
  220 + memcpy( &frameData[0], buf + i, frameDataLen);
  221 +
  222 + //让画面帧强跳到第一帧
  223 + frame = 1;
  224 +
  225 + continue;
  226 + }
  227 +
  228 + //如果是第一帧
  229 + if (frame == 1)
  230 + {
  231 + memcpy( &frameData[frameDataLen], buf, frame_len-frameDataLen );
  232 +
  233 + JZC1_IrcDeal(frameData, frame_len);
  234 +
  235 + frame = 2;
  236 + frameDataLen = 0;
  237 + //memset(frameData,0,sizeof(frameData));
  238 + }
  239 +
  240 +
  241 + //如果不是第1帧，且上段数据小于一画面段，说明为数据被切割
  242 + if ( i<frame_len)
  243 + {
  244 + //则于前端残余数据拼接，并输出
  245 + if (frame%2==0 && (frame != 1) )
  246 + {
  247 +
  248 + memcpy( &frameData[frame_len-i], buf, i);
  249 + //将未处理raw数据放入缓冲区
  250 +
  251 + //JZSDK_LOG_INFO("写入1 %d %x", i, frameData[20]);
  252 +
  253 + JZC1_IrcDeal(frameData, frame_len);
  254 + //JZSDK_LOG_INFO("放入数据到缓冲区");
  255 + //memset(frameData,0,sizeof(frameData));
  256 + }
  257 + frame++;
  258 + }
  259 +
  260 + //如果剩余长度超出一画数据，将画面数据整段输出
  261 + if ( (i + frame_len) < realLen)
  262 + {
  263 + if (frame%2==0)
  264 + {
  265 + //JZSDK_LOG_INFO("写入2");
  266 +
  267 + memcpy( &frameData[0], buf, frame_len);
  268 +
  269 + //将未处理raw数据放入缓冲区
  270 + JZC1_IrcDeal(frameData, frame_len);
  271 + //JZSDK_LOG_INFO("放入数据到缓冲区");
  272 + }
  273 + frame++;
  274 + continue;
  275 + }
  276 +
  277 + //JZSDK_LOG_INFO("i:%d, frame_len:%d realLen:%d frame:%d",i,frame_len,realLen,frame);
  278 +
  279 + //如果剩余数据小于一画，存进画面缓冲区
  280 + //memset(frameData,0,sizeof(frameData));
  281 + memcpy(frameData, buf+i, (realLen-i));
  282 + break;
  283 + }
  284 + }
  285 +}
  286 +
  287 +
  288 +//C1 红外相机数据的初始化
  289 +static T_JZsdkReturnCode JZsdk_JZC1_Irc_Data_Init()
  290 +{
  291 + T_JZsdkReturnCode ret;
  292 +
  293 + //初始化接收的usb口
  294 + ret = JZsdk_HalUsbBulk_Init(&g_usb_index, 0, 0, LINUX_USB_PID, LINUX_USB_VID, USB_IN_POINT, USB_OUT_POINT);
  295 + if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
  296 + {
  297 + return ret;
  298 + }
  299 +
  300 + //初始化usb接收线程
  301 + pthread_t ReadDataTask;
  302 + pthread_attr_t task_attribute; //线程属性
  303 + pthread_attr_init(&task_attribute); //初始化线程属性
  304 + pthread_attr_setdetachstate(&task_attribute, PTHREAD_CREATE_DETACHED); //设置线程分离属性
  305 + int opus_Protection = pthread_create(&ReadDataTask,&task_attribute,JZC1_IrcDataRecv_Thread,NULL); //线程
  306 + if(opus_Protection != 0)
  307 + {
  308 + JZSDK_LOG_ERROR("创建视频usb线程失败！");
  309 + return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
  310 + }
  311 +
  312 + return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
  313 +}
  314 +
  315 +
  316 +
  317 +//JZ_C1 的媒体初始化
  318 +static T_JZsdkReturnCode JZC1_MediaInit()
  319 +{
  320 + T_JZsdkReturnCode ret = JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
  321 +
  322 +
  323 +//初始化媒体模块
  324 +#ifdef MEDIA_PROC_CONFIG_STATUS_ON
  325 +
  326 + //初始化videoMgmt模块
  327 + VideoMgmt_Init();
  328 +
  329 + //初始化Mulit模块
  330 + #ifdef RTK_MPP_STATUS_ON
  331 + //初始化红外的编解码器
  332 + RTK_mmp_enc_Init(JZsdk_RtkMmpGetEncHandleAddr(0), MPP_VIDEO_CodingAVC, MPP_FMT_YUV420P, FIRST_WIDTH, FIRST_HEIGHT, 25, 5);
  333 +
  334 + //初始化光学的编解码器
  335 + RTK_mmp_dec_Init(JZsdk_RtkMmpGetDecHandleAddr(1), MPP_VIDEO_CodingMJPEG, MPP_FMT_YUV420SP, SECOND_WIDTH, SECOND_HEIGHT);
  336 + RTK_mmp_enc_Init(JZsdk_RtkMmpGetEncHandleAddr(1), MPP_VIDEO_CodingAVC, MPP_FMT_YUV420SP, SECOND_WIDTH, SECOND_HEIGHT, 30, 15);
  337 + #endif
  338 +
  339 + //初始化Camera模块
  340 + int CameraFd = -1;
  341 + ret = V4l2_Camarainit2(&CameraFd, SECOND_WIDTH, SECOND_HEIGHT, 30);
  342 + if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
  343 + {
  344 + JZSDK_LOG_ERROR("光学相机启动失败");
  345 + }
  346 + else
  347 + {
  348 + //光学相机的抓取
  349 + ret = JZsdk_FrameCatch_Single(JZC1_OptDeal);
  350 + }
  351 +
  352 + //初始化IRC_funtion模块
  353 + ret = IRC_ParamInit(FIRST_HEIGHT, FIRST_WIDTH, 25);
  354 + if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
  355 + {
  356 + JZSDK_LOG_ERROR("初始化红外的数据处理失败");
  357 + }
  358 + else
  359 + {
  360 + //初始化红外的数据输入
  361 + ret = JZsdk_JZC1_Irc_Data_Init();
  362 + if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
  363 + {
  364 + JZSDK_LOG_ERROR("红外相机初始化失败");
  365 + }
  366 + }
  367 +
  368 + //设置默认参数
  369 +
  370 + //默认推送红外摄像头 后续改成 红外+光学 的组合画面
  371 + VideoMgmt_VideoStreamFlowIndex(VIDEOMGMT_STREAMING_FLOW_INDEX_FIRST);
  372 +
  373 + //设置快门为开
  374 + JZsdk_Camera_ShutterSwitch(JZ_FLAGCODE_ON);
  375 +
  376 + //设置伪彩颜色
  377 + int value = 8;
  378 + Camera_param(JZ_FLAGCODE_SET, CAMERA_PSEUDO_COLOR, &value);
  379 +
  380 + //设置伪彩模式
  381 + value = 1;
  382 + Camera_param(JZ_FLAGCODE_SET, CAMERA_PIXEL_PSEUDO_COLOR_MODE, &value);
  383 +
  384 +#endif
  385 +
  386 +
  387 + return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
  388 +}
  389 +
  390 +
  391 +T_JZsdkReturnCode JZC1_Init()
  392 +{
  393 + T_JZsdkReturnCode ret;
  394 +
  395 + //初始化引脚
  396 + Ircut_Init();
  397 +
  398 + //初始化媒体模块
  399 + ret = JZC1_MediaInit();
  400 +
  401 + JZSDK_LOG_INFO("JZ_C1 INIT COMPLETED\n");
  402 +
  403 + return ret;
  404 +}
  405 +
  406 +
  407 +
  408 +
  409 +
  410 +
  411 +
  412 +
  413 +
  414 +
  415 +
  416 +
  417 +
  418 +
  1 +/**
  2 + ********************************************************************
  3 + * @file JZC1.h
  4 + * JZC1.h的头文件
  5 + *
  6 + *********************************************************************
  7 + */
  8 +
  9 +/* Define to prevent recursive inclusion 避免重定义 -------------------------------------*/
  10 +#ifndef JZC1_H
  11 +#define JZC1_H
  12 +
  13 +#include "JZsdk_Base/JZsdk_Code/JZsdk_Code.h"
  14 +
  15 +
  16 +/* Includes ------------------------------------------------------------------*/
  17 +#ifdef __cplusplus
  18 +extern "C" {
  19 +#endif
  20 +
  21 +
  22 +
  23 +/* Exported constants --------------------------------------------------------*/
  24 +/* 常亮定义*/
  25 +
  26 +/* Exported types ------------------------------------------------------------*/
  27 +
  28 +T_JZsdkReturnCode JZC1_Init();
  29 +
  30 +
  31 +#ifdef __cplusplus
  32 +}
  33 +#endif
  34 +
  35 +#endif
@@ -20,8 +20,8 @@ static int CameraFd = 0; @@ -20,8 +20,8 @@ static int CameraFd = 0;
20 //临时方案 后续会改写法合并到t_JZsdk_TaskFuntionInput（搞起来有点麻烦） 20 //临时方案 后续会改写法合并到t_JZsdk_TaskFuntionInput（搞起来有点麻烦）
21 typedef struct t_FrameCatch_TaskFuntionInput 21 typedef struct t_FrameCatch_TaskFuntionInput
22 { 22 {
23 - void (*task_function)(void*); //任务函数指针,用于指定 执行的任务  
24 - void* data; //数据指针 23 + void (*task_function)(unsigned char*, unsigned int); //任务函数指针,用于指定 执行的任务
  24 + unsigned* data; //数据指针
25 unsigned int data_size; //数据大小 25 unsigned int data_size; //数据大小
26 } t_FrameCatch_TaskFuntionInput; 26 } t_FrameCatch_TaskFuntionInput;
27 27
@@ -71,12 +71,12 @@ T_JZsdkReturnCode JZsdk_FrameCatch_Init(int ThreadMode) @@ -71,12 +71,12 @@ T_JZsdkReturnCode JZsdk_FrameCatch_Init(int ThreadMode)
71 71
72 if (ThreadMode == 0) 72 if (ThreadMode == 0)
73 { 73 {
74 - int opus_Protection = pthread_create(&ReadDataTask,&task_attribute,JZsdk_Catch_SingleThread,NULL); //线程  
75 - if(opus_Protection != 0)  
76 - {  
77 - JZSDK_LOG_ERROR("创建相机抓取并处理初始化线程失败！");  
78 - return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;  
79 - } 74 + // int opus_Protection = pthread_create(&ReadDataTask,&task_attribute,JZsdk_Catch_SingleThread,NULL); //线程
  75 + // if(opus_Protection != 0)
  76 + // {
  77 + // JZSDK_LOG_ERROR("创建相机抓取并处理初始化线程失败！");
  78 + // return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
  79 + // }
80 } 80 }
81 else if (ThreadMode == 1) 81 else if (ThreadMode == 1)
82 { 82 {
@@ -92,15 +92,43 @@ T_JZsdkReturnCode JZsdk_FrameCatch_Init(int ThreadMode) @@ -92,15 +92,43 @@ T_JZsdkReturnCode JZsdk_FrameCatch_Init(int ThreadMode)
92 } 92 }
93 93
94 94
  95 +/*******************************************************************************************************************************************/
  96 +
  97 +//多线程抓取数据线程
  98 +static void *JZsdk_Catch_MultiThread2(void *args)
  99 +{
  100 + while (1)
  101 + {
  102 + unsigned int buf_size = 0;
  103 + unsigned char *buf = NULL;
  104 +
  105 + //从相机中读取一张照片
  106 + V4L2_CameraFrameRecord_OnlyGetFrame(&buf, &buf_size);
  107 +
  108 + //printf("read: len:%d data[3]:%x data[4]:%x\n", buf_size, buf[3], buf[4]);
  109 +
  110 + if (buf == NULL)
  111 + {
  112 + JZSDK_LOG_ERROR("相机数据读取失败");
  113 + continue;
  114 + }
  115 +
  116 + //放入缓冲池 //将数据放入缓冲池，从而被其他线程使用
  117 + VideoMgmt_write_data(&args, buf, buf_size);
  118 +
  119 + //归还图片
  120 + V4L2_CameraFrameRecord_OnlyReturnFrame();
  121 + }
  122 +}
95 123
96 124
97 //单线程抓取数据线程 125 //单线程抓取数据线程
98 static void *JZsdk_Catch_SingleThread2(void *args) 126 static void *JZsdk_Catch_SingleThread2(void *args)
99 { 127 {
100 t_FrameCatch_TaskFuntionInput *task = (t_FrameCatch_TaskFuntionInput *)args; 128 t_FrameCatch_TaskFuntionInput *task = (t_FrameCatch_TaskFuntionInput *)args;
  129 +
101 while (1) 130 while (1)
102 { 131 {
103 - task->task_function();  
104 132
105 unsigned int buf_size = 0; 133 unsigned int buf_size = 0;
106 unsigned char *buf = NULL; 134 unsigned char *buf = NULL;
@@ -108,7 +136,7 @@ static void *JZsdk_Catch_SingleThread2(void *args) @@ -108,7 +136,7 @@ static void *JZsdk_Catch_SingleThread2(void *args)
108 //从相机中读取一张照片 136 //从相机中读取一张照片
109 V4L2_CameraFrameRecord_OnlyGetFrame(&buf, &buf_size); 137 V4L2_CameraFrameRecord_OnlyGetFrame(&buf, &buf_size);
110 138
111 - //printf("read: len:%d data[3]:%x data[4]:%x\n", buf_size, buf[3], buf[4]); 139 + //JZSDK_LOG_INFO("read: len:%d data[3]:%x data[4]:%x\n", buf_size, buf[3], buf[4]);
112 140
113 if (buf == NULL) 141 if (buf == NULL)
114 { 142 {
@@ -117,9 +145,7 @@ static void *JZsdk_Catch_SingleThread2(void *args) @@ -117,9 +145,7 @@ static void *JZsdk_Catch_SingleThread2(void *args)
117 } 145 }
118 146
119 //进行数据处理 147 //进行数据处理
120 - VideoMgmt_Single_FrameIn(buf, buf_size);  
121 -  
122 - task->task_function(); 148 + task->task_function(buf, buf_size);
123 149
124 //归还图片 150 //归还图片
125 V4L2_CameraFrameRecord_OnlyReturnFrame(); 151 V4L2_CameraFrameRecord_OnlyReturnFrame();
@@ -130,13 +156,12 @@ static void *JZsdk_Catch_SingleThread2(void *args) @@ -130,13 +156,12 @@ static void *JZsdk_Catch_SingleThread2(void *args)
130 /******************************************** 156 /********************************************
131 * 157 *
132 * 158 *
133 - * 相机抓取初始化 159 + * 相机抓取多线程单线程
134 * 160 *
135 - * 传入线程的抓取模式 ThreadMode: 0为单线程 1为多线程  
136 * 传入线程的处理函数 task_function 161 * 传入线程的处理函数 task_function
137 * 162 *
138 * *****************************************/ 163 * *****************************************/
139 -T_JZsdkReturnCode JZsdk_FrameCatch_Init2(int ThreadMode, T_JZsdkReturnCode (*task_function)(void*)) 164 +T_JZsdkReturnCode JZsdk_FrameCatch_Single(T_JZsdkReturnCode (*task_function)(unsigned char*, unsigned int))
140 { 165 {
141 T_JZsdkReturnCode ret; 166 T_JZsdkReturnCode ret;
142 167
@@ -146,34 +171,61 @@ T_JZsdkReturnCode JZsdk_FrameCatch_Init2(int ThreadMode, T_JZsdkReturnCode (*tas @@ -146,34 +171,61 @@ T_JZsdkReturnCode JZsdk_FrameCatch_Init2(int ThreadMode, T_JZsdkReturnCode (*tas
146 pthread_attr_init(&task_attribute); //初始化线程属性 171 pthread_attr_init(&task_attribute); //初始化线程属性
147 pthread_attr_setdetachstate(&task_attribute, PTHREAD_CREATE_DETACHED); //设置线程分离属性 172 pthread_attr_setdetachstate(&task_attribute, PTHREAD_CREATE_DETACHED); //设置线程分离属性
148 173
  174 +
  175 + //单线程模式
  176 + if (task_function == NULL)
  177 + {
  178 + return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
  179 + }
  180 +
149 t_FrameCatch_TaskFuntionInput *task = (t_FrameCatch_TaskFuntionInput*)malloc(sizeof(t_FrameCatch_TaskFuntionInput)); 181 t_FrameCatch_TaskFuntionInput *task = (t_FrameCatch_TaskFuntionInput*)malloc(sizeof(t_FrameCatch_TaskFuntionInput));
150 if (task == NULL) 182 if (task == NULL)
151 { 183 {
152 // 处理内存分配失败的情况 184 // 处理内存分配失败的情况
153 - return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE; 185 + return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
154 } 186 }
155 187
156 task->task_function = task_function; 188 task->task_function = task_function;
157 - task->args = NULL;  
158 189
159 - if (ThreadMode == 0)  
160 - {  
161 - int opus_Protection = pthread_create(&ReadDataTask,&task_attribute,JZsdk_Catch_SingleThread,(void *)task); //线程 190 + int opus_Protection = pthread_create(&ReadDataTask,&task_attribute,JZsdk_Catch_SingleThread2,(void *)task); //线程
162 if(opus_Protection != 0) 191 if(opus_Protection != 0)
163 { 192 {
164 JZSDK_LOG_ERROR("创建相机抓取并处理初始化线程失败！"); 193 JZSDK_LOG_ERROR("创建相机抓取并处理初始化线程失败！");
165 return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE; 194 return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
166 } 195 }
167 - }  
168 - else if (ThreadMode == 1) 196 +
  197 + return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
  198 +}
  199 +
  200 +/*************************
  201 + *
  202 + *
  203 + * 相机抓取多线程
  204 + *
  205 + *
  206 + * ******************/
  207 +T_JZsdkReturnCode JZsdk_FrameCatch_Multi(void *FrameIndex)
  208 +{
  209 + T_JZsdkReturnCode ret;
  210 +
  211 + //初始化数据接收线程
  212 + pthread_t ReadDataTask;
  213 + pthread_attr_t task_attribute; //线程属性
  214 + pthread_attr_init(&task_attribute); //初始化线程属性
  215 + pthread_attr_setdetachstate(&task_attribute, PTHREAD_CREATE_DETACHED); //设置线程分离属性
  216 +
  217 + if (FrameIndex == NULL)
169 { 218 {
170 - int opus_Protection = pthread_create(&ReadDataTask,&task_attribute,JZsdk_Catch_MultiThread,(void *)task); //线程 219 + return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
  220 + }
  221 +
  222 +
  223 + int opus_Protection = pthread_create(&ReadDataTask,&task_attribute,JZsdk_Catch_MultiThread2, FrameIndex); //线程
171 if(opus_Protection != 0) 224 if(opus_Protection != 0)
172 { 225 {
173 JZSDK_LOG_ERROR("创建相机抓取并处理初始化线程失败！"); 226 JZSDK_LOG_ERROR("创建相机抓取并处理初始化线程失败！");
174 return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE; 227 return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
175 } 228 }
176 - }  
177 229
178 return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS; 230 return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
179 } 231 }
@@ -25,7 +25,8 @@ extern "C" { @@ -25,7 +25,8 @@ extern "C" {
25 25
26 /* Exported functions --------------------------------------------------------*/ 26 /* Exported functions --------------------------------------------------------*/
27 T_JZsdkReturnCode JZsdk_FrameCatch_Init(int ThreadMode); 27 T_JZsdkReturnCode JZsdk_FrameCatch_Init(int ThreadMode);
28 - 28 +T_JZsdkReturnCode JZsdk_FrameCatch_Single(T_JZsdkReturnCode (*task_function)(unsigned char*, unsigned int));
  29 +T_JZsdkReturnCode JZsdk_FrameCatch_Multi(void *FrameIndex);
29 30
30 31
31 #ifdef __cplusplus 32 #ifdef __cplusplus
@@ -8,9 +8,9 @@ @@ -8,9 +8,9 @@
8 #include "./Camera.h" 8 #include "./Camera.h"
9 #include "version_choose.h" 9 #include "version_choose.h"
10 #include "BaseConfig.h" 10 #include "BaseConfig.h"
11 -#include "./Kt_Irc/Kt_Irc.h"  
12 #include "../ImageProc/PseudoColor/PseudoColor.h" 11 #include "../ImageProc/PseudoColor/PseudoColor.h"
13 #include "MediaProc/MediaProc_Param.h" 12 #include "MediaProc/MediaProc_Param.h"
  13 +#include "Ircut/ircut.h"
14 14
15 #include "MediaProc/IRC_funtion/IRC_funtion.h" 15 #include "MediaProc/IRC_funtion/IRC_funtion.h"
16 16
@@ -68,6 +68,8 @@ T_JZsdkReturnCode Camera_Init(int ThreadMode, int width, int height, int frame_n @@ -68,6 +68,8 @@ T_JZsdkReturnCode Camera_Init(int ThreadMode, int width, int height, int frame_n
68 68
69 } 69 }
70 70
  71 +
  72 +
71 //快门开关 73 //快门开关
72 /*********************************** 74 /***********************************
73 * 75 *
@@ -79,7 +81,20 @@ T_JZsdkReturnCode JZsdk_Camera_ShutterSwitch(int value) @@ -79,7 +81,20 @@ T_JZsdkReturnCode JZsdk_Camera_ShutterSwitch(int value)
79 { 81 {
80 T_JZsdkReturnCode ret; 82 T_JZsdkReturnCode ret;
81 #if DEVICE_VERSION == JZ_C1 83 #if DEVICE_VERSION == JZ_C1
82 - ret = JZsdk_Kt_Irc_ShutterSwitch(value); 84 +
  85 + if (value == JZ_FLAGCODE_ON)
  86 + {
  87 + ret = SysfsGPIO_Set_ircut(KT_IRC_SHUTTER_GPIO_NUM, 1);
  88 + }
  89 + else if (value == JZ_FLAGCODE_OFF)
  90 + {
  91 + ret = SysfsGPIO_Set_ircut(KT_IRC_SHUTTER_GPIO_NUM, 0);
  92 + }
  93 + else
  94 + {
  95 + ret = JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
  96 + }
  97 +
83 #else 98 #else
84 ret = JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE; 99 ret = JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
85 #endif 100 #endif
1 -  
2 -#include <stdio.h>  
3 -#include "MediaProc.h"  
4 -#include "IrcC1.h"  
5 -#include "MediaParm.h"  
6 -  
7 -#include "JZsdkLib.h"  
8 -#include "BaseConfig.h"  
9 -  
10 -#ifdef RTK_MPP_STATUS_ON  
11 -  
12 -#include "MediaProc/MultProc/RTK_mmp/RTK_mmp.h"  
13 -  
14 -//c1的红外编码权柄  
15 -void *JZC1_Irc_enc_handle = NULL;  
16 -  
17 -//c1的光学相机编码权柄  
18 -void *JZC1_Opt_enc_handle = NULL;  
19 -void *JZC1_Opt_dec_handle = NULL;  
20 -  
21 -#endif  
22 -  
23 -T_JZsdkReturnCode JZC1_Init()  
24 -{  
25 - T_JZsdkReturnCode ret = JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;  
26 -  
27 -#ifdef RTK_MPP_STATUS_ON  
28 - //1、初始化编解码模块  
29 -  
30 - //初始化红外的编解码器  
31 - RTK_mmp_enc_Init(&JZC1_Irc_enc_handle, MPP_VIDEO_CodingAVC, MPP_FMT_YUV420P, FIRST_WIDTH, FIRST_HEIGHT, 25, 5);  
32 -  
33 - //初始化光学的编解码器  
34 - RTK_mmp_enc_Init(&JZC1_Opt_enc_handle, MPP_VIDEO_CodingAVC, MPP_FMT_YUV420P, SECOND_WIDTH, SECOND_HEIGHT, 25, 5);  
35 - RTK_mmp_dec_Init(&JZC1_Opt_dec_handle, MPP_VIDEO_CodingAVC, MPP_FMT_YUV420P, SECOND_WIDTH, SECOND_HEIGHT, 30, 15);  
36 -  
37 - //2、相机初始化  
38 - Camera_Init();  
39 -  
40 - //初始化光学相机  
41 - ret = JZsdk_Kt_Camera_Init();  
42 - if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)  
43 - {  
44 - JZSDK_LOG_ERROR("光学相机初始化失败");  
45 - }  
46 - else  
47 - {  
48 - //初始化数据转换模块  
49 - JZsdk_Kt_Cam_DataDeal_Init();  
50 - }  
51 -  
52 -  
53 -#endif  
54 -}  
1 -#include <stdio.h>  
2 -#include <string.h>  
3 -#include <stdlib.h>  
4 -#include <pthread.h>  
5 -#include <unistd.h>  
6 -  
7 -#include "JZsdkLib.h"  
8 -#include "version_choose.h"  
9 -#include "BaseConfig.h"  
10 -  
11 -  
12 -#include "JZsdk_usb_bulk/JZsdk_usb_bulk.h"  
13 -#include "../V4L2_camera/V4L2_Record.h"  
14 -#include "../../MultProc/MultProc.h"  
15 -#include "../../MediaParm.h"  
16 -#include "../../VideoMgmt/VideoMgmt.h"  
17 -#include "Ircut/ircut.h"  
18 -#include "../Camera.h"  
19 -  
20 -#include "UI_control/UI_control.h"  
21 -#include "../../IRC_funtion/IRC_Param.h"  
22 -#include "../../IRC_funtion/IRC_funtion.h"  
23 -  
24 -#define IRC_WIDTH FIRST_WIDTH  
25 -#define IRC_HEIGHT FIRST_HEIGHT  
26 -  
27 -#define CAMERA_WIDTH SECOND_WIDTH  
28 -#define CAMERA_HEIGHT SECOND_HEIGHT  
29 -  
30 -static int Kt_Camera_fd;  
31 -  
32 -extern IRC_param *g_IRC_Param;  
33 -  
34 -  
35 -#define IRC_WIDTH FIRST_WIDTH  
36 -#define IRC_HEIGHT FIRST_HEIGHT  
37 -  
38 -// 定义帧头长度和帧头内容  
39 -#define FRAME_HEADER_SIZE 4  
40 -  
41 -static const unsigned char FRAME_HEADER[FRAME_HEADER_SIZE] = {0xaa, 0xbb, 0xcc, 0xdd};  
42 -  
43 -  
44 -static void *Irc_usb_index = NULL;  
45 -  
46 -//红外数据纠正函数, 暂定全部替换  
47 -T_JZsdkReturnCode Kt_Irc_DataCorrect(unsigned char *data)  
48 -{  
49 - //像素修正  
50 - data[0] = data[5];  
51 - data[1] = data[6];  
52 - data[2] = data[5];  
53 - data[3] = data[6];  
54 -}  
55 -  
56 -  
57 -//红外数据接收线程  
58 -static void *JZsdk_Kt_Irc_DataRecv_Thread(void *args)  
59 -{  
60 - int frame_len = IRC_WIDTH*2*IRC_HEIGHT; //163840  
61 - unsigned char buf[163840]; //usb数据缓冲区需要为512的倍数 4194304 后续考虑为 262144  
62 - unsigned char frameData[frame_len]; // 存储整帧数据的画面缓冲区  
63 - unsigned int lineNum = 0;  
64 - int frame = 0;  
65 - int frameDataLen = 0;//缓冲区的数据长度  
66 -  
67 - /*****  
68 - *  
69 - * 数据格式说明  
70 - *  
71 - * 帧头 0xaa 0xbb 0x02 0x80 0x01 0x00 + 行数 如第一行0x00 0x01  
72 - * 数据包长度为 0x0280  
73 - * 数据包 一包的行数为256 0x0100  
74 - * 当前数据为第x行 x= 0x0001  
75 - * 两位数据为一个点  
76 - * 接着把前4个点的数据 用第五个点替换掉  
77 - * *****/  
78 -  
79 - while (1)  
80 - {  
81 - int realLen;  
82 - memset(buf,0,sizeof(buf));  
83 - T_JZsdkReturnCode ret = JZsdk_HalUsbBulk_ReadData(&Irc_usb_index, buf, sizeof(buf), &realLen);  
84 - if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)  
85 - {  
86 - // 处理读取错误  
87 - JZSDK_LOG_ERROR("读取错误");  
88 - continue;  
89 - //return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;  
90 - }  
91 - if (realLen != 0)  
92 - {  
93 - //JZSDK_LOG_INFO("读取到%d 字节",realLen);  
94 - }  
95 -  
96 - //寻找数据是否存在帧头  
97 - for (int i = 0; i < realLen; i++)  
98 - {  
99 - // 验证帧头  
100 - if (memcmp(buf+i, FRAME_HEADER, FRAME_HEADER_SIZE) != 0)  
101 - {  
102 - // 帧头不匹配，可能是噪声或错误的数据包  
103 - continue;  
104 - }  
105 -  
106 -/**********************  
107 - *  
108 - * 方法一，将usb缓冲区调整大小 到超过640*256， 然后直接输出整段画面，避免重复复制，节省处理时间  
109 - *  
110 - * ******************************/  
111 - //如果查找到帧头  
112 -  
113 - //查看是否是第0帧  
114 - if (frame == 0)  
115 - {  
116 - //重置掉画面缓冲区  
117 - memset(frameData,0,sizeof(frameData));  
118 -  
119 - //将数据置于缓冲区  
120 - frameDataLen = (realLen-i);  
121 - memcpy( &frameData[0], buf + i, frameDataLen);  
122 -  
123 - //让画面帧强跳到第一帧  
124 - frame = 1;  
125 -  
126 - continue;  
127 - }  
128 -  
129 - //如果是第一帧  
130 - if (frame == 1)  
131 - {  
132 - memcpy( &frameData[frameDataLen], buf, frame_len-frameDataLen );  
133 -  
134 - VideoMgmt_write_data(&VideoMgmt_FirstRaw_index, frameData, frame_len);  
135 -  
136 - frame = 2;  
137 - frameDataLen = 0;  
138 - //memset(frameData,0,sizeof(frameData));  
139 - }  
140 -  
141 -  
142 - //如果不是第1帧，且上段数据小于一画面段，说明为数据被切割  
143 - if ( i<frame_len)  
144 - {  
145 - //则于前端残余数据拼接，并输出  
146 - if (frame%2==0 && (frame != 1) )  
147 - {  
148 -  
149 - memcpy( &frameData[frame_len-i], buf, i);  
150 - //将未处理raw数据放入缓冲区  
151 -  
152 - //JZSDK_LOG_INFO("写入1 %d %x", i, frameData[20]);  
153 -  
154 - VideoMgmt_write_data(&VideoMgmt_FirstRaw_index, frameData, frame_len);  
155 - //JZSDK_LOG_INFO("放入数据到缓冲区");  
156 - //memset(frameData,0,sizeof(frameData));  
157 - }  
158 - frame++;  
159 - }  
160 -  
161 - //如果剩余长度超出一画数据，将画面数据整段输出  
162 - if ( (i + frame_len) < realLen)  
163 - {  
164 - if (frame%2==0)  
165 - {  
166 - //JZSDK_LOG_INFO("写入2");  
167 -  
168 - memcpy( &frameData[0], buf, frame_len);  
169 -  
170 - //将未处理raw数据放入缓冲区  
171 - VideoMgmt_write_data(&VideoMgmt_FirstRaw_index, frameData, frame_len);  
172 - //JZSDK_LOG_INFO("放入数据到缓冲区");  
173 - }  
174 - frame++;  
175 - continue;  
176 - }  
177 -  
178 - //JZSDK_LOG_INFO("i:%d, frame_len:%d realLen:%d frame:%d",i,frame_len,realLen,frame);  
179 -  
180 - //如果剩余数据小于一画，存进画面缓冲区  
181 - //memset(frameData,0,sizeof(frameData));  
182 - memcpy(frameData, buf+i, (realLen-i));  
183 - break;  
184 - }  
185 - }  
186 -}  
187 -  
188 -//红外相机数据的初始化  
189 -T_JZsdkReturnCode JZsdk_Kt_Irc_Data_Init()  
190 -{  
191 - T_JZsdkReturnCode ret;  
192 -  
193 - //初始化接收的usb口  
194 - ret = JZsdk_HalUsbBulk_Init(&Irc_usb_index, 0, 0, LINUX_USB_PID, LINUX_USB_VID, USB_IN_POINT, USB_OUT_POINT);  
195 - if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)  
196 - {  
197 - return ret;  
198 - }  
199 -  
200 - //初始化usb接收线程  
201 - pthread_t ReadDataTask;  
202 - pthread_attr_t task_attribute; //线程属性  
203 - pthread_attr_init(&task_attribute); //初始化线程属性  
204 - pthread_attr_setdetachstate(&task_attribute, PTHREAD_CREATE_DETACHED); //设置线程分离属性  
205 - int opus_Protection = pthread_create(&ReadDataTask,&task_attribute,JZsdk_Kt_Irc_DataRecv_Thread,NULL); //线程  
206 - if(opus_Protection != 0)  
207 - {  
208 - JZSDK_LOG_ERROR("创建视频usb线程失败！");  
209 - return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;  
210 - }  
211 -  
212 - return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;  
213 -}  
214 -  
215 -  
216 -//红外数据的处理  
217 -static void *JZsdk_Kt_Irc_DataDeal_Thread(void *args)  
218 -{  
219 - int DealFrameNum = 0;  
220 - unsigned char BaseBuffer[IRC_WIDTH*2*IRC_HEIGHT];  
221 -  
222 - while (1)  
223 - {  
224 - unsigned char *gary_data = NULL;  
225 - unsigned int gary_data_len;  
226 - //1、从原始流缓冲区中取出raw数据  
227 - VideoMgmt_read_data(&VideoMgmt_FirstRaw_index, &gary_data, &gary_data_len,JZ_FLAGCODE_OFF ,JZ_FLAGCODE_OFF);  
228 -  
229 - //2、红外数据纠正处理  
230 - Kt_Irc_DataCorrect(gary_data);  
231 -  
232 - //3、将灰度图数据转换为原始码流数据  
233 - unsigned char *raw_data = NULL;  
234 - int raw_data_len = 0;  
235 - IRC_FrameDeal(gary_data, gary_data_len, &raw_data, &raw_data_len);  
236 -  
237 - //4、将原始码流数据转换成h264流，为避免多次复制，这里的h264会直接放入视频流管理的缓冲区  
238 - JZsdk_RTKMMP_RawData_to_h264(raw_data, raw_data_len);  
239 -  
240 - //5、释放内存  
241 - if (raw_data != NULL)  
242 - {  
243 - if (raw_data != NULL)  
244 - {  
245 - free(raw_data);  
246 - raw_data = NULL;  
247 - }  
248 -  
249 - if (gary_data != NULL)  
250 - {  
251 - }  
252 -  
253 - if (gary_data != NULL)  
254 - {  
255 - free(gary_data);  
256 - gary_data = NULL;  
257 - }  
258 - }  
259 -  
260 - //JZSDK_LOG_DEBUG("得到了一帧红外h264");  
261 - }  
262 -}  
263 -  
264 -//红外相机数据的处理线程  
265 -static T_JZsdkReturnCode JZsdk_Kt_Irc_DataDeal_Init()  
266 -{  
267 - pthread_t ReadDataTask;  
268 - pthread_attr_t task_attribute; //线程属性  
269 - pthread_attr_init(&task_attribute); //初始化线程属性  
270 - pthread_attr_setdetachstate(&task_attribute, PTHREAD_CREATE_DETACHED); //设置线程分离属性  
271 - int opus_Protection = pthread_create(&ReadDataTask,&task_attribute,JZsdk_Kt_Irc_DataDeal_Thread,NULL); //线程  
272 - if(opus_Protection != 0)  
273 - {  
274 - JZSDK_LOG_ERROR("创建红外相机数据的处理线程失败！");  
275 - return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;  
276 - }  
277 -  
278 - return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;  
279 -}  
280 -  
281 -//光学相机数据的处理线程  
282 -static void *JZsdk_Kt_Cam_DataDeal_Thread(void *args)  
283 -{  
284 - int DealFrameNum = 0;  
285 - while (1)  
286 - {  
287 - unsigned char *raw_data = NULL;  
288 - unsigned int raw_data_len;  
289 - //1、从原始流缓冲区中取出raw数据  
290 - VideoMgmt_read_data(&VideoMgmt_SecondRaw_index, &raw_data, &raw_data_len,JZ_FLAGCODE_OFF ,JZ_FLAGCODE_OFF);  
291 -  
292 - //2、将raw数据流转换成h264流，并放置到视频流缓冲区  
293 - JZsdk_Kt_CamMMP_Mjpeg_to_h264(raw_data, raw_data_len);  
294 -  
295 - free(raw_data);  
296 - raw_data = NULL;  
297 -  
298 - //DealFrameNum++;  
299 - //printf("get Cam Frame%d\n",DealFrameNum);  
300 -  
301 - }  
302 -}  
303 -  
304 -//光学相机数据的处理线程  
305 -static T_JZsdkReturnCode JZsdk_Kt_Cam_DataDeal_Init()  
306 -{  
307 - pthread_t ReadDataTask;  
308 - pthread_attr_t task_attribute; //线程属性  
309 - pthread_attr_init(&task_attribute); //初始化线程属性  
310 - pthread_attr_setdetachstate(&task_attribute, PTHREAD_CREATE_DETACHED); //设置线程分离属性  
311 - int opus_Protection = pthread_create(&ReadDataTask,&task_attribute,JZsdk_Kt_Cam_DataDeal_Thread,NULL); //线程  
312 - if(opus_Protection != 0)  
313 - {  
314 - JZSDK_LOG_ERROR("创建红外相机数据的处理线程失败！");  
315 - return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;  
316 - }  
317 -  
318 - return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;  
319 -}  
320 -  
321 -//光学相机数据读取线程  
322 -static void *JZsdk_Kt_Cam_Data_Thread(void *args)  
323 -{  
324 - while (1)  
325 - {  
326 - unsigned int buf_size = 0;  
327 - unsigned char *buf = NULL;  
328 -  
329 - //从相机中读取一张照片  
330 - V4L2_CameraFrameRecord_OnlyGetFrame(&buf, &buf_size);  
331 -  
332 - if (buf == NULL)  
333 - {  
334 - JZSDK_LOG_ERROR("相机数据读取失败");  
335 - continue;  
336 - }  
337 -  
338 -  
339 - //放入缓冲池  
340 - VideoMgmt_write_data(&VideoMgmt_SecondRaw_index, buf, buf_size);  
341 -  
342 - //归还图片  
343 - V4L2_CameraFrameRecord_OnlyReturnFrame();  
344 - }  
345 -}  
346 -  
347 -//光学相机初始化  
348 -static T_JZsdkReturnCode JZsdk_Kt_Camera_Init()  
349 -{  
350 - T_JZsdkReturnCode ret;  
351 -  
352 - //初始化摄像头  
353 - ret = V4l2_Camarainit2(&Kt_Camera_fd,CAMERA_WIDTH,CAMERA_HEIGHT,30);  
354 - if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)  
355 - {  
356 - return ret;  
357 - }  
358 -  
359 -  
360 - //初始化数据接收线程  
361 - pthread_t ReadDataTask;  
362 - pthread_attr_t task_attribute; //线程属性  
363 - pthread_attr_init(&task_attribute); //初始化线程属性  
364 - pthread_attr_setdetachstate(&task_attribute, PTHREAD_CREATE_DETACHED); //设置线程分离属性  
365 - int opus_Protection = pthread_create(&ReadDataTask,&task_attribute,JZsdk_Kt_Cam_Data_Thread,NULL); //线程  
366 - if(opus_Protection != 0)  
367 - {  
368 - JZSDK_LOG_ERROR("创建v4l2线程失败！");  
369 - return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;  
370 - }  
371 -  
372 - return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;  
373 -}  
374 -  
375 -//昆腾相机初始化  
376 -T_JZsdkReturnCode JZsdk_Kt_Irc_Camera_Init()  
377 -{  
378 - T_JZsdkReturnCode ret;  
379 -  
380 - //1、初始化光学相机  
381 - ret = JZsdk_Kt_Camera_Init();  
382 - if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)  
383 - {  
384 - JZSDK_LOG_ERROR("光学相机初始化失败");  
385 - }  
386 - else  
387 - {  
388 - //初始化数据转换模块  
389 - JZsdk_Kt_Cam_DataDeal_Init();  
390 - }  
391 -  
392 - //2、初始化红外的数据处理  
393 - ret = IRC_ParamInit(&g_IRC_Param, IRC_HEIGHT, IRC_WIDTH, 25);  
394 - if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)  
395 - {  
396 - JZSDK_LOG_ERROR("初始化红外的数据处理失败");  
397 - }  
398 -  
399 - //3、初始化红外的数据输入  
400 - ret = JZsdk_Kt_Irc_Data_Init();  
401 - if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)  
402 - {  
403 - JZSDK_LOG_ERROR("红外相机初始化失败");  
404 - }  
405 - else  
406 - {  
407 - //初始化数据转换模块  
408 - JZsdk_Kt_Irc_DataDeal_Init();  
409 - }  
410 -  
411 - JZSDK_LOG_INFO("KT_Irc init complete");  
412 -  
413 - return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;  
414 -}  
415 -  
416 -//昆腾的红外相机的快门开关  
417 -/***********************************  
418 - *  
419 - * value on为开 off为关  
420 - *  
421 - *  
422 - * ***************************************/  
423 -T_JZsdkReturnCode JZsdk_Kt_Irc_ShutterSwitch(int value)  
424 -{  
425 - T_JZsdkReturnCode ret;  
426 - if (value == JZ_FLAGCODE_ON)  
427 - {  
428 - ret = SysfsGPIO_Set_ircut(KT_IRC_SHUTTER_GPIO_NUM, 1);  
429 - }  
430 - else if (value == JZ_FLAGCODE_OFF)  
431 - {  
432 - ret = SysfsGPIO_Set_ircut(KT_IRC_SHUTTER_GPIO_NUM, 0);  
433 - }  
434 - else  
435 - {  
436 - ret = JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;  
437 - }  
438 -  
439 - return ret;  
440 -}  
441 -  
@@ -30,11 +30,11 @@ static T_JZsdkReturnCode IRC_param_Init(struct IRC_param **index, int height, in @@ -30,11 +30,11 @@ static T_JZsdkReturnCode IRC_param_Init(struct IRC_param **index, int height, in
30 备注： 30 备注：
31 31
32 */ 32 */
33 -T_JZsdkReturnCode IRC_ParamInit(struct IRC_param **index, int height, int width, int frameRate) 33 +T_JZsdkReturnCode IRC_ParamInit(int height, int width, int frameRate)
34 { 34 {
35 T_JZsdkReturnCode ret; 35 T_JZsdkReturnCode ret;
36 36
37 - IRC_param_Init(index, height, width, frameRate); 37 + ret = IRC_param_Init(&g_IRC_Param, height, width, frameRate);
38 38
39 if (g_IRC_Param->DealWay ==IRC_DEALMODE_KTLIB) 39 if (g_IRC_Param->DealWay ==IRC_DEALMODE_KTLIB)
40 { 40 {
@@ -66,7 +66,7 @@ static T_JZsdkReturnCode IRC_data_PreliminaryDeal(U8_t *rawData , int dataSize, @@ -66,7 +66,7 @@ static T_JZsdkReturnCode IRC_data_PreliminaryDeal(U8_t *rawData , int dataSize,
66 ret = JZsdk_Merge_U8_to_U16_byReverse(rawData, dataSize, returnData, returnDataSize); 66 ret = JZsdk_Merge_U8_to_U16_byReverse(rawData, dataSize, returnData, returnDataSize);
67 if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS || *returnDataSize != dealInfo->PixelNum) 67 if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS || *returnDataSize != dealInfo->PixelNum)
68 { 68 {
69 - JZSDK_LOG_ERROR("像素合成失败"); 69 + JZSDK_LOG_ERROR("像素合成失败, ret:0x%x dataSize:%d returnDataSize:%d PixelNum:%d", ret, dataSize,*returnDataSize, dealInfo->PixelNum);
70 return ret; 70 return ret;
71 } 71 }
72 72
@@ -26,7 +26,7 @@ extern "C" { @@ -26,7 +26,7 @@ extern "C" {
26 26
27 /* Exported functions --------------------------------------------------------*/ 27 /* Exported functions --------------------------------------------------------*/
28 28
29 -T_JZsdkReturnCode IRC_ParamInit(struct IRC_param **index, int height, int width, int frameRate); 29 +T_JZsdkReturnCode IRC_ParamInit(int height, int width, int frameRate);
30 T_JZsdkReturnCode IRC_FrameDeal(unsigned char *rawData ,unsigned int dataSize, unsigned char **outData, unsigned int *outDataSize); 30 T_JZsdkReturnCode IRC_FrameDeal(unsigned char *rawData ,unsigned int dataSize, unsigned char **outData, unsigned int *outDataSize);
31 31
32 T_JZsdkReturnCode IRC_SetRawPixel_ResetFlag(); 32 T_JZsdkReturnCode IRC_SetRawPixel_ResetFlag();
@@ -116,6 +116,7 @@ T_JZsdkReturnCode PseudoColor_Gray2Rgb(U8_t *in_str, U8_t **out_str, unsigned in @@ -116,6 +116,7 @@ T_JZsdkReturnCode PseudoColor_Gray2Rgb(U8_t *in_str, U8_t **out_str, unsigned in
116 { 116 {
117 if (P_Color_FinishFlag != JZ_FLAGCODE_ON) 117 if (P_Color_FinishFlag != JZ_FLAGCODE_ON)
118 { 118 {
  119 + JZSDK_LOG_ERROR("伪彩配置文件未初始化");
119 return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE; 120 return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
120 } 121 }
121 122
@@ -123,6 +124,7 @@ T_JZsdkReturnCode PseudoColor_Gray2Rgb(U8_t *in_str, U8_t **out_str, unsigned in @@ -123,6 +124,7 @@ T_JZsdkReturnCode PseudoColor_Gray2Rgb(U8_t *in_str, U8_t **out_str, unsigned in
123 *out_str = (unsigned char*)malloc(*out_str_len * sizeof(unsigned char)); 124 *out_str = (unsigned char*)malloc(*out_str_len * sizeof(unsigned char));
124 if (out_str == NULL) 125 if (out_str == NULL)
125 { 126 {
  127 + JZSDK_LOG_ERROR("内存分配失败");
126 return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER; 128 return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
127 } 129 }
128 130
@@ -12,7 +12,6 @@ @@ -12,7 +12,6 @@
12 #include "./MultProc/MultProc.h" 12 #include "./MultProc/MultProc.h"
13 #include "./MediaParm.h" 13 #include "./MediaParm.h"
14 #include "./Camera/Camera.h" 14 #include "./Camera/Camera.h"
15 -#include "./Camera/Kt_Irc/Kt_Irc.h"  
16 15
17 //单线程方案 16 //单线程方案
18 static T_JZsdkReturnCode MediaProc_SingleThreading() 17 static T_JZsdkReturnCode MediaProc_SingleThreading()
@@ -26,13 +25,6 @@ static T_JZsdkReturnCode MediaProc_SingleThreading() @@ -26,13 +25,6 @@ static T_JZsdkReturnCode MediaProc_SingleThreading()
26 //2、转码模块初始化 25 //2、转码模块初始化
27 VideoStreamTransCode_Init(); 26 VideoStreamTransCode_Init();
28 } 27 }
29 -  
30 - //如果是昆腾相机 红外+光学 则红外为1号，光学为2号  
31 - if (DEVICE_VERSION == JZ_C1)  
32 - {  
33 - //1、初始化编解码处理模块  
34 - JZsdk_Kt_IrcMMP_Init(FIRST_WIDTH ,FIRST_HEIGHT, 25, 5 ,SECOND_WIDTH ,SECOND_HEIGHT, 30, 15);  
35 - }  
36 } 28 }
37 29
38 //多线程方案 30 //多线程方案
@@ -55,41 +47,6 @@ static T_JZsdkReturnCode MediaProc_MultiThreading() @@ -55,41 +47,6 @@ static T_JZsdkReturnCode MediaProc_MultiThreading()
55 47
56 VideoMgmt_VideoStreamFlowIndex(VIDEOMGMT_STREAMING_FLOW_INDEX_FIRST); //默认推送光学摄像头 48 VideoMgmt_VideoStreamFlowIndex(VIDEOMGMT_STREAMING_FLOW_INDEX_FIRST); //默认推送光学摄像头
57 } 49 }
58 -  
59 - //如果是昆腾相机 红外+光学 则红外为1号，光学为2号  
60 - if (DEVICE_VERSION == JZ_C1)  
61 - {  
62 - //1、启动视频流缓冲区模块  
63 - VideoMgmt_init_buffer(&VideoMgmt_FirstVideo_index);  
64 - VideoMgmt_init_buffer(&VideoMgmt_FirstRaw_index);  
65 -  
66 - VideoMgmt_init_buffer(&VideoMgmt_SecondVideo_index);  
67 - VideoMgmt_init_buffer(&VideoMgmt_SecondRaw_index);  
68 -  
69 - //2、初始化编解码处理模块  
70 - JZsdk_Kt_IrcMMP_Init(FIRST_WIDTH ,FIRST_HEIGHT, 25, 5 ,SECOND_WIDTH ,SECOND_HEIGHT, 30, 15);  
71 -  
72 - //3、相机初始化  
73 - JZsdk_Kt_Irc_Camera_Init();  
74 -  
75 - //4、启用推流模块  
76 - VideoMgmt_VideoStreamFlow_Init(25, &VideoMgmt_FirstVideo_index, VIDEOMGMT_STREAMING_FLOW_INDEX_FIRST);  
77 - VideoMgmt_VideoStreamFlow_Init(30, &VideoMgmt_SecondVideo_index, VIDEOMGMT_STREAMING_FLOW_INDEX_SECOND);  
78 -  
79 - //转码模块  
80 - VideoStreamTransCode_Init();  
81 -  
82 - //5、打开默认选项  
83 - VideoMgmt_VideoStreamFlowIndex(VIDEOMGMT_STREAMING_FLOW_INDEX_FIRST); //默认推送红外摄像头 后续改成 红外+光学 的组合画面  
84 - JZsdk_Kt_Irc_ShutterSwitch(JZ_FLAGCODE_ON);  
85 -  
86 - //6、修改部分参数  
87 - int value = 8;  
88 - Camera_param(JZ_FLAGCODE_SET, CAMERA_PSEUDO_COLOR, &value);  
89 - value = 1;  
90 - Camera_param(JZ_FLAGCODE_SET, CAMERA_PIXEL_PSEUDO_COLOR_MODE, &value);  
91 - }  
92 -  
93 } 50 }
94 51
95 //视频流模块初始化 52 //视频流模块初始化
@@ -98,8 +55,6 @@ T_JZsdkReturnCode MediaProc_Init() @@ -98,8 +55,6 @@ T_JZsdkReturnCode MediaProc_Init()
98 55
99 #if DEVICE_VERSION == JZ_H150S || DEVICE_VERSION == JZ_H150T 56 #if DEVICE_VERSION == JZ_H150S || DEVICE_VERSION == JZ_H150T
100 MediaProc_SingleThreading(); 57 MediaProc_SingleThreading();
101 -# elif DEVICE_VERSION == JZ_C1  
102 - MediaProc_MultiThreading();  
103 #endif 58 #endif
104 59
105 return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS; 60 return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
@@ -7,75 +7,52 @@ @@ -7,75 +7,52 @@
7 #include "version_choose.h" 7 #include "version_choose.h"
8 #include "MediaProc/VideoMgmt/VideoMgmt.h" 8 #include "MediaProc/VideoMgmt/VideoMgmt.h"
9 9
10 -void *Kt_Irc_enc_index = NULL; //昆腾红外编码器的索引值  
11 -void *Kt_Cam_enc_index = NULL; //昆腾光学编码器的索引值  
12 -void *Kt_Cam_dec_index = NULL; //昆腾光学解码器的索引值 10 +//c1 0是红外权柄 1是光学权柄 2为空权柄
  11 +static void *RtkMmpEncHandle[3] = { NULL }; // 所有元素都被初始化为NULL
  12 +static void *RtkMmpDecHandle[3] = { NULL }; // 所有元素都被初始化为NULL
13 13
14 -//昆腾红外相机的mmp初始化部分  
15 -T_JZsdkReturnCode JZsdk_Kt_IrcMMP_Init(int Irc_width, int Irc_height, int Irc_frame, int Irc_gop, int Cam_width, int Cam_height, int Cam_frame,int Cam_gop)  
16 -{  
17 -#if RTK_MPP_STATUS == VERSION_SWITCH_ON  
18 - //初始化红外数据的编码器  
19 - RTK_mmp_enc_Init(&Kt_Irc_enc_index, MPP_VIDEO_CodingAVC, MPP_FMT_YUV420P, Irc_width, Irc_height, Irc_frame, Irc_gop);  
20 - //RTK_mmp_enc_Init(&Kt_Irc_enc_index, MPP_VIDEO_CodingAVC, MPP_FMT_RGB888, Irc_width, Irc_height, Irc_frame);  
21 -  
22 - //初始化光学数据的编解码器  
23 - RTK_mmp_dec_Init(&Kt_Cam_dec_index, MPP_VIDEO_CodingMJPEG, MPP_FMT_YUV420SP, Cam_width, Cam_height);  
24 - RTK_mmp_enc_Init(&Kt_Cam_enc_index, MPP_VIDEO_CodingAVC, MPP_FMT_YUV420SP, Cam_width, Cam_height, Cam_frame, Cam_gop);  
25 -#endif  
26 -} 14 +/*
  15 + rtk模块获取编码权柄
  16 + 属于参数即可权柄
27 17
28 -//原始视频流通过rtkmmp转为h264  
29 -T_JZsdkReturnCode JZsdk_RTKMMP_RawData_to_h264(unsigned char *RawData, int data_len) 18 +*/
  19 +void *JZsdk_RtkMmpGetEncHandle(int CameraIndex)
30 { 20 {
31 -#if RTK_MPP_STATUS == VERSION_SWITCH_ON  
32 - MppPacket Packet = NULL; 21 + return RtkMmpEncHandle[CameraIndex];
  22 +}
33 23
34 - RTK_mmp_enc_data_to_h264(&Kt_Irc_enc_index, RawData, data_len, &Packet);  
35 24
36 - int packet_len = mpp_packet_get_length(Packet);  
37 - void *ptr = mpp_packet_get_pos(Packet);  
38 - //EncCfg->Packet_eos = mpp_packet_get_eos(packet);  
39 - // printf("获取到编码内容 len:%d\n",packet_len);  
40 25
41 - //3、将h264流输出到视频流缓冲区  
42 - VideoMgmt_write_data(&VideoMgmt_FirstVideo_index, ptr, packet_len); 26 +/*
  27 + rtk模块获取解码权柄
  28 + 属于参数即可权柄
43 29
44 - //释放掉packet  
45 - mpp_packet_deinit(&Packet);  
46 -#endif 30 +*/
  31 +void *JZsdk_RtkMmpGetDecHandle(int CameraIndex)
  32 +{
  33 + return RtkMmpDecHandle[CameraIndex];
47 } 34 }
48 35
49 -//昆腾光学相机数据输入部分  
50 -T_JZsdkReturnCode JZsdk_Kt_CamMMP_Mjpeg_to_h264(unsigned char *data, int data_len) 36 +/*********
  37 + *
  38 + * 返回dec权柄地址
  39 + *
  40 + *
  41 + * ***/
  42 +void **JZsdk_RtkMmpGetDecHandleAddr(int CameraIndex)
51 { 43 {
52 -#if RTK_MPP_STATUS == VERSION_SWITCH_ON  
53 - MppFrame yuv_data = NULL; //用于传递yuv数据的地址  
54 - MppPacket Packet = NULL;  
55 -  
56 - //输入数据进入解码器  
57 - RTK_mmp_dec_input(&Kt_Cam_dec_index, data, data_len, &yuv_data);  
58 -  
59 - // int width = mpp_frame_get_width(yuv_data);  
60 - // int height = mpp_frame_get_height(yuv_data);  
61 - // int h_stride = mpp_frame_get_hor_stride(yuv_data);  
62 - // int v_stride = mpp_frame_get_ver_stride(yuv_data);  
63 -  
64 - // JZSDK_LOG_INFO("w:%d h:%d hor:%d ver:%d",width,height,h_stride,v_stride);  
65 -  
66 - //将返回的数据输入进编码器  
67 - RTK_mmp_enc_yuv_to_h264_byFrame(&Kt_Cam_enc_index, yuv_data, &Packet);  
68 -  
69 - //获取数据指针与长度  
70 - int packet_len = mpp_packet_get_length(Packet);  
71 - void *ptr = mpp_packet_get_pos(Packet);  
72 -  
73 - //置入视频缓冲区  
74 - VideoMgmt_write_data(&VideoMgmt_SecondVideo_index, (unsigned char *)ptr, (unsigned int)packet_len); 44 + return &(RtkMmpDecHandle[CameraIndex]);
  45 +}
75 46
76 - //释放掉编码图像  
77 - mpp_packet_deinit(&Packet);  
78 -#endif 47 +/*********
  48 + *
  49 + * 返回enc权柄地址
  50 + *
  51 + *
  52 + * ***/
  53 +void **JZsdk_RtkMmpGetEncHandleAddr(int CameraIndex)
  54 +{
  55 + return &(RtkMmpEncHandle[CameraIndex]);
79 } 56 }
80 57
81 //昆腾相机设置下一帧为I帧 58 //昆腾相机设置下一帧为I帧
@@ -84,11 +61,11 @@ T_JZsdkReturnCode JZsdk_Kt_CamMMPenc_SetNextFrame_IDR(int CameraIndex) @@ -84,11 +61,11 @@ T_JZsdkReturnCode JZsdk_Kt_CamMMPenc_SetNextFrame_IDR(int CameraIndex)
84 #if RTK_MPP_STATUS == VERSION_SWITCH_ON 61 #if RTK_MPP_STATUS == VERSION_SWITCH_ON
85 if (CameraIndex == 0) 62 if (CameraIndex == 0)
86 { 63 {
87 - RTK_mmp_enc_SetNextFrame_IDR(&Kt_Irc_enc_index); 64 + RTK_mmp_enc_SetNextFrame_IDR(JZsdk_RtkMmpGetEncHandleAddr(0));
88 } 65 }
89 else if(CameraIndex == 1) 66 else if(CameraIndex == 1)
90 { 67 {
91 - RTK_mmp_enc_SetNextFrame_IDR(&Kt_Cam_enc_index); 68 + RTK_mmp_enc_SetNextFrame_IDR(JZsdk_RtkMmpGetEncHandleAddr(1));
92 } 69 }
93 else 70 else
94 { 71 {
@@ -35,9 +35,17 @@ extern "C" { @@ -35,9 +35,17 @@ extern "C" {
35 /* Exported functions --------------------------------------------------------*/ 35 /* Exported functions --------------------------------------------------------*/
36 T_JZsdkReturnCode JZsdk_Kt_CamMMP_Mjpeg_to_h264(unsigned char *data, int data_len); 36 T_JZsdkReturnCode JZsdk_Kt_CamMMP_Mjpeg_to_h264(unsigned char *data, int data_len);
37 T_JZsdkReturnCode JZsdk_RTKMMP_RawData_to_h264(unsigned char *RawData, int data_len); 37 T_JZsdkReturnCode JZsdk_RTKMMP_RawData_to_h264(unsigned char *RawData, int data_len);
  38 +T_JZsdkReturnCode JZsdk_RTKMMP_RawData_to_h264_Return(void **index, unsigned char *RawData, int *data_len);
  39 +
38 T_JZsdkReturnCode JZsdk_Kt_IrcMMP_Init(int Irc_width, int Irc_height, int Irc_frame, int Irc_gop, int Cam_width, int Cam_height, int Cam_frame,int Cam_gop); 40 T_JZsdkReturnCode JZsdk_Kt_IrcMMP_Init(int Irc_width, int Irc_height, int Irc_frame, int Irc_gop, int Cam_width, int Cam_height, int Cam_frame,int Cam_gop);
39 T_JZsdkReturnCode JZsdk_Kt_CamMMPenc_SetNextFrame_IDR(int CameraIndex); 41 T_JZsdkReturnCode JZsdk_Kt_CamMMPenc_SetNextFrame_IDR(int CameraIndex);
40 42
  43 +void *JZsdk_RtkMmpGetEncHandle(int CameraIndex);
  44 +void *JZsdk_RtkMmpGetDecHandle(int CameraIndex);
  45 +
  46 +void **JZsdk_RtkMmpGetDecHandleAddr(int CameraIndex);
  47 +void **JZsdk_RtkMmpGetEncHandleAddr(int CameraIndex);
  48 +
41 49
42 50
43 #ifdef __cplusplus 51 #ifdef __cplusplus
@@ -32,6 +32,11 @@ @@ -32,6 +32,11 @@
32 32
33 JZ_VideoStreamUseStatus g_VideoStreamDealStatus = VIDEO_STREAM_IDLE; //视频流的处理状态 33 JZ_VideoStreamUseStatus g_VideoStreamDealStatus = VIDEO_STREAM_IDLE; //视频流的处理状态
34 static int g_VideoFreezeFlag = JZ_FLAGCODE_OFF; //视频流冻结功能 34 static int g_VideoFreezeFlag = JZ_FLAGCODE_OFF; //视频流冻结功能
  35 +static int g_VideoFreeze_PlayFlag = JZ_FLAGCODE_OFF; //视频流冻结功能的传输flag
  36 +
  37 +//视频流冻结的缓存区
  38 +static unsigned char *g_FreezeData = NULL; //当前使用的缓存区
  39 +static unsigned int FreezeDataLen = 0;
35 40
36 /********************************************************************************************************************************************* 41 /*********************************************************************************************************************************************
37 * 42 *
@@ -44,6 +49,8 @@ static int g_VideoFreezeFlag = JZ_FLAGCODE_OFF; //视频流冻结功能 @@ -44,6 +49,8 @@ static int g_VideoFreezeFlag = JZ_FLAGCODE_OFF; //视频流冻结功能
44 49
45 static int g_VideoStreamFlowIndexNum = JZ_FLAGCODE_OFF; //视频流转的索引值 50 static int g_VideoStreamFlowIndexNum = JZ_FLAGCODE_OFF; //视频流转的索引值
46 51
  52 +
  53 +//获取视频索引
47 int VideoMgmt_GetVideoStreamFlowIndexNum() 54 int VideoMgmt_GetVideoStreamFlowIndexNum()
48 { 55 {
49 return g_VideoStreamFlowIndexNum; 56 return g_VideoStreamFlowIndexNum;
@@ -149,6 +156,18 @@ T_JZsdkReturnCode VideoStramPhoto_DevelopH264FlowGenerateIDR() @@ -149,6 +156,18 @@ T_JZsdkReturnCode VideoStramPhoto_DevelopH264FlowGenerateIDR()
149 return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS; 156 return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
150 } 157 }
151 158
  159 +
  160 +static void *Pthread_FreezeTime(void *arg)
  161 +{
  162 + //每500ms 恢复一次冻结画面
  163 + while (1)
  164 + {
  165 + delayMs(500);
  166 + g_VideoFreeze_PlayFlag = JZ_FLAGCODE_ON;
  167 + }
  168 +}
  169 +
  170 +
152 /************** 171 /**************
153 * 172 *
154 * 视频流流转的线程 173 * 视频流流转的线程
@@ -157,6 +176,40 @@ T_JZsdkReturnCode VideoStramPhoto_DevelopH264FlowGenerateIDR() @@ -157,6 +176,40 @@ T_JZsdkReturnCode VideoStramPhoto_DevelopH264FlowGenerateIDR()
157 * ************/ 176 * ************/
158 T_JZsdkReturnCode VideoMgmt_VideoStreamToDeal(unsigned char *data, unsigned int data_len) 177 T_JZsdkReturnCode VideoMgmt_VideoStreamToDeal(unsigned char *data, unsigned int data_len)
159 { 178 {
  179 + //出错
  180 + if (data == NULL)
  181 + {
  182 + return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
  183 + }
  184 +
  185 + //冻结数据处理
  186 + int VideoFreezeFlag = g_VideoFreezeFlag;
  187 +
  188 + //如果冻结功能未打开
  189 + if (VideoFreezeFlag == JZ_FLAGCODE_OFF)
  190 + {
  191 + if (g_FreezeData != NULL)
  192 + {
  193 + free(g_FreezeData);
  194 + g_FreezeData = NULL;
  195 + }
  196 +
  197 + }
  198 + //冻结功能打开
  199 + else if (VideoFreezeFlag == JZ_FLAGCODE_ON)
  200 + {
  201 + //如果冻结数据为空，且 当前为i帧
  202 + if (g_FreezeData == NULL && data[4] == 0x67)
  203 + {
  204 + FreezeDataLen = data_len;
  205 + JZsdk_Malloc((void **)&g_FreezeData, data_len);
  206 + memcpy(g_FreezeData, data , data_len);
  207 + }
  208 + }
  209 +
  210 + //没有冻结数据的情况下
  211 + if (g_FreezeData == NULL)
  212 + {
160 //拍照数据 213 //拍照数据
161 VideoStramPhoto_PhotoDataIn(data, data_len); 214 VideoStramPhoto_PhotoDataIn(data, data_len);
162 215
@@ -168,7 +221,27 @@ T_JZsdkReturnCode VideoMgmt_VideoStreamToDeal(unsigned char *data, unsigned int @@ -168,7 +221,27 @@ T_JZsdkReturnCode VideoMgmt_VideoStreamToDeal(unsigned char *data, unsigned int
168 221
169 //推流 222 //推流
170 VideoStream_PushFrame(data, data_len); 223 VideoStream_PushFrame(data, data_len);
171 - //JZSDK_LOG_INFO("推送一帧%d,数据大小%d\n",VideoPush->VideoStreamFlowIndex,data_len); 224 + }
  225 + else
  226 + {
  227 + //拍照数据
  228 + VideoStramPhoto_PhotoDataIn(g_FreezeData, FreezeDataLen);
  229 +
  230 + //录像处理函数
  231 + VideoStramRecord_RecordDataIn(g_FreezeData, FreezeDataLen);
  232 +
  233 + //连拍处理函数
  234 + //FrameDeal_ShootPhotoBurstDeal(g_FreezeData, FreezeDataLen);
  235 +
  236 + //推流
  237 + if (g_VideoFreeze_PlayFlag == JZ_FLAGCODE_ON)
  238 + {
  239 + VideoStream_PushFrame(g_FreezeData, FreezeDataLen);
  240 + g_VideoFreeze_PlayFlag = JZ_FLAGCODE_OFF;
  241 + }
  242 + }
  243 +
  244 + return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
172 } 245 }
173 246
174 247
@@ -330,3 +403,33 @@ T_JZsdkReturnCode VideoMgmt_Get_StreamWidthAndHeight(int *width, int *height) @@ -330,3 +403,33 @@ T_JZsdkReturnCode VideoMgmt_Get_StreamWidthAndHeight(int *width, int *height)
330 403
331 return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS; 404 return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
332 } 405 }
  406 +
  407 +/*******************
  408 + *
  409 + *
  410 + * videoMgmt初始化
  411 + *
  412 + *
  413 + *
  414 + * ***********************/
  415 +T_JZsdkReturnCode VideoMgmt_Init(void)
  416 +{
  417 + T_JZsdkReturnCode ret;
  418 +
  419 + //初始化转码模块
  420 + VideoStreamTransCode_Init();
  421 +
  422 + //冻结计时模块
  423 + //创建视频流流转线程
  424 + pthread_t FreezeTask;
  425 + pthread_attr_t task_attribute; //线程属性
  426 + pthread_attr_init(&task_attribute); //初始化线程属性
  427 + pthread_attr_setdetachstate(&task_attribute, PTHREAD_CREATE_DETACHED); //设置线程分离属性
  428 + int p_ret = pthread_create(&FreezeTask,&task_attribute,(void *)Pthread_FreezeTime,NULL); //线程
  429 + if(p_ret != 0)
  430 + {
  431 + JZSDK_LOG_ERROR("创建冻结计时线程失败!");
  432 + }
  433 +
  434 + return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
  435 +}
@@ -25,6 +25,7 @@ extern "C" { @@ -25,6 +25,7 @@ extern "C" {
25 /* Exported types ------------------------------------------------------------*/ 25 /* Exported types ------------------------------------------------------------*/
26 26
27 /* Exported functions --------------------------------------------------------*/ 27 /* Exported functions --------------------------------------------------------*/
  28 +T_JZsdkReturnCode VideoMgmt_Init(void);
28 T_JZsdkReturnCode VideoMgmt_init_buffer(void **index); 29 T_JZsdkReturnCode VideoMgmt_init_buffer(void **index);
29 T_JZsdkReturnCode VideoMgmt_VideoBuffer_Deinit(void **index); 30 T_JZsdkReturnCode VideoMgmt_VideoBuffer_Deinit(void **index);
30 T_JZsdkReturnCode VideoMgmt_write_data(void **index, unsigned char *data, unsigned int data_len); 31 T_JZsdkReturnCode VideoMgmt_write_data(void **index, unsigned char *data, unsigned int data_len);
@@ -202,16 +202,8 @@ static int Video_TransCode_Thread_Init() @@ -202,16 +202,8 @@ static int Video_TransCode_Thread_Init()
202 * ********/ 202 * ********/
203 T_JZsdkReturnCode VideoStreamTransCode_Init() 203 T_JZsdkReturnCode VideoStreamTransCode_Init()
204 { 204 {
205 - if (DEVICE_VERSION == JZ_H150S  
206 - || DEVICE_VERSION == JZ_H150T  
207 - || DEVICE_VERSION == JZ_C1)  
208 - { 205 +
209 Video_TransCode_Thread_Init(); 206 Video_TransCode_Thread_Init();
210 - }  
211 - else  
212 - {  
213 - return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;  
214 - }  
215 207
216 JZSDK_LOG_INFO("transcode module init success"); 208 JZSDK_LOG_INFO("transcode module init success");
217 209
@@ -187,7 +187,7 @@ T_JZsdkReturnCode AttentionVoice_IndependencePlay() @@ -187,7 +187,7 @@ T_JZsdkReturnCode AttentionVoice_IndependencePlay()
187 187
188 if (language == 0x11) 188 if (language == 0x11)
189 { 189 {
190 - Megaphone_TTS_Play("Upgrade defeat, restarting Megaphone.", strlen("Upgrade defeat, restarting Megaphone."), JZ_FLAGCODE_ON); 190 + Megaphone_TTS_Play("Megaphone starting.", strlen("Megaphone starting."), JZ_FLAGCODE_ON);
191 } 191 }
192 else 192 else
193 { 193 {
1 # cmake 最低版本要求 第三行名字不能动 1 # cmake 最低版本要求 第三行名字不能动
2 cmake_minimum_required(VERSION 2.8) 2 cmake_minimum_required(VERSION 2.8)
3 -project(JZ_H150S) 3 +project(JZ_C1)
4 4
5 set(CMAKE_C_FLAGS "-pthread -std=gnu99 -lm -ldl -lstdc++") 5 set(CMAKE_C_FLAGS "-pthread -std=gnu99 -lm -ldl -lstdc++")
6 #"-pthread":指定在编译时链接POSIX线程库,以支持多线程程序。 6 #"-pthread":指定在编译时链接POSIX线程库,以支持多线程程序。