潘浩彬 / JZSDK_Linux · 提交

转到一个项目

作者 ookk303
提交 5f5c864f9351a7c619796af6766fc1f0913eb766 1 个父辈 c5cd8767

00212更新 2025/1/3 

优化了jsdklib的code部分,加入了 最新最潮的osal库
昆腾红外相机修改为最新的sdk,并修复了高低温数据溢出的问题
修复了mp3实时语音的崩溃问题
优化了hal层 处理修改了hal相关的关系
    移除了无帧头帧尾的不健康帧
简化了uart的层，使得再也不会混进奇怪的内容了
    数据传输上限修改至2048，优化了打印，使得数据传输快了
优化了log.c避免log日志没有及时保存导致的丢失
内嵌 并排对比
正在显示 53 个修改的文件 包含 1640 行增加 和 269 行删除
@@ -99,7 +99,14 @@ @@ -99,7 +99,14 @@
99 "jzsdk_flagcode.h": "c", 99 "jzsdk_flagcode.h": "c",
100 "jzsdk_typedef.h": "c", 100 "jzsdk_typedef.h": "c",
101 "jzsdk_errorcode.h": "c", 101 "jzsdk_errorcode.h": "c",
102 - "jzsdk_portcode.h": "c" 102 + "jzsdk_portcode.h": "c",
  103 + "jzsdk_osal.h": "c",
  104 + "jzsdk_time.h": "c",
  105 + "jzsdk_task.h": "c",
  106 + "jzsdk_semaphore.h": "c",
  107 + "jzsdk_filesystm.h": "c",
  108 + "jzsdk_memoryadapter.h": "c",
  109 + "jzsdk_errorcodedef.h": "c"
103 }, 110 },
104 "Codegeex.GenerationPreference": "automatic", 111 "Codegeex.GenerationPreference": "automatic",
105 "C_Cpp.dimInactiveRegions": false 112 "C_Cpp.dimInactiveRegions": false
1 # 编译链的配置 1 # 编译链的配置
2 2
3 #1、编译链与设备类型的选择 3 #1、编译链与设备类型的选择
4 -set(DEVICE_NAME JZ_C1) 4 +set(DEVICE_NAME JZ_H10)
5 #上一行为禁止修改行 5 #上一行为禁止修改行
6 6
7 message("**************************JZSDK构建编译开始***************************\n") 7 message("**************************JZSDK构建编译开始***************************\n")
1 #include <stdio.h> 1 #include <stdio.h>
2 #include "JZsdkLib.h" 2 #include "JZsdkLib.h"
  3 +
3 #include "./JZsdk_TaskManagement/TaskManagement.h" 4 #include "./JZsdk_TaskManagement/TaskManagement.h"
4 5
  6 +static T_JZsdkReturnCode JZsdk_PrepareSystemEnvironment()
  7 +{
  8 + T_JZsdkReturnCode ret;
  9 +
  10 + ret = JZsdk_OsalInit();
  11 + if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
  12 + {
  13 +
  14 + }
  15 + else
  16 + {
  17 + JZSDK_LOG_INFO("JZSDK_OSAL_INIT_SUCCESS");
  18 + }
  19 +
  20 + return ret;
  21 +}
  22 +
  23 +
5 //初始化sdk 24 //初始化sdk
6 T_JZsdkReturnCode JZsdk_LibInit() 25 T_JZsdkReturnCode JZsdk_LibInit()
7 { 26 {
  27 + //环境初始化
  28 + JZsdk_PrepareSystemEnvironment();
  29 +
8 //1、初始化log 30 //1、初始化log
9 JZsdk_LoggerInit(); 31 JZsdk_LoggerInit();
10 32
11 //2、任务管理系统初始化 33 //2、任务管理系统初始化
12 TaskManagement_Init(); 34 TaskManagement_Init();
13 35
14 - JZSDK_LOG_INFO("Lib加载已完成"); 36 + JZSDK_LOG_INFO("JZSDK_LIB_INIT_SUCCESS");
15 } 37 }
@@ -19,11 +19,8 @@ extern "C" { @@ -19,11 +19,8 @@ extern "C" {
19 /* Exported constants --------------------------------------------------------*/ 19 /* Exported constants --------------------------------------------------------*/
20 /* 常亮定义*/ 20 /* 常亮定义*/
21 #include "JZsdk_Logger/JZsdk_Logger.h" 21 #include "JZsdk_Logger/JZsdk_Logger.h"
22 -#include "JZsdk_Osal/JZsdk_FileSystm.h"  
23 -#include "JZsdk_Delay/JZsdk_Delay.h"  
24 #include "JZsdk_Code/JZsdk_FLagCode.h" 22 #include "JZsdk_Code/JZsdk_FLagCode.h"
25 -#include "JZsdk_Osal/JZsdk_MemoryAdapter.h"  
26 -#include "JZsdk_Osal/JZsdk_CheckSum/JZsdk_CheckSum.h" 23 +#include "JZsdk_Osal/JZsdk_Osal.h"
27 24
28 /* Exported types ------------------------------------------------------------*/ 25 /* Exported types ------------------------------------------------------------*/
29 26
@@ -19,10 +19,12 @@ extern "C" { @@ -19,10 +19,12 @@ extern "C" {
19 /* Exported constants --------------------------------------------------------*/ 19 /* Exported constants --------------------------------------------------------*/
20 /* 常亮定义*/ 20 /* 常亮定义*/
21 21
  22 +#include "./JZsdk_typedef/JZsdk_typedef.h"
  23 +#include "./JZsdk_ReturnCode/JZsdk_ReturnCode.h"
  24 +
  25 +
22 #include "./JZsdk_InsCode.h" 26 #include "./JZsdk_InsCode.h"
23 #include "./JZsdk_FLagCode.h" 27 #include "./JZsdk_FLagCode.h"
24 -#include "./JZsdk_ReturnCode.h"  
25 -#include "./JZsdk_FileType.h"  
26 #include "./JZsdk_WidgetCode.h" 28 #include "./JZsdk_WidgetCode.h"
27 #include "./JZsdk_DeviceCode.h" 29 #include "./JZsdk_DeviceCode.h"
28 #include "./JZsdk_DefineCode.h" 30 #include "./JZsdk_DefineCode.h"
@@ -7,62 +7,26 @@ @@ -7,62 +7,26 @@
7 #define JZSDK_DEVICE_CODE_H 7 #define JZSDK_DEVICE_CODE_H
8 8
9 //特殊版本号 9 //特殊版本号
10 -typedef enum SpecialVersion  
11 -{  
12 - SPECIAL_NORMAL = 0x01, //普通版本  
13 - SPECIAL_DAOTONG = 0x02, //道通版本  
14 -}SpecialVersion; 10 +#define SPECIAL_NORMAL 0x01 //普通版本
  11 +#define SPECIAL_DAOTONG 0x02 //道通版本
15 12
16 //软件模式 13 //软件模式
17 -typedef enum AppMode  
18 -{  
19 - APP_PSDK = 0x01, //psdk设备  
20 - APP_UART = 0x02, //串口设备  
21 - APP_TEST = 0x03, //测试设备  
22 -}AppMode; 14 +#define APP_PSDK 0x01
  15 +#define APP_UART 0x02
  16 +#define APP_TEST 0x03
23 17
24 //平台选择 18 //平台选择
25 -typedef enum Platform  
26 -{  
27 - PLATFORM_H3 = 0x01, //H3平台  
28 - PLATFORM_V3S = 0x02, //V3S平台  
29 -}Platform; 19 +#define PLATFORM_H3 0x01
  20 +#define PLATFORM_V3S 0x02
30 21
31 //固件属地 22 //固件属地
32 -typedef enum FirmwarePlace  
33 -{  
34 - OVERSEAS_VERSION = 0x01, //海外版  
35 - DOMESTIC_VERSION = 0x02, //国内版  
36 -}FirmwarePlace; 23 +#define OVERSEAS_VERSION 0x01
  24 +#define DOMESTIC_VERSION 0x02
37 25
38 //加载开关 26 //加载开关
39 -// typedef enum VersionLoadSwitch  
40 -// {  
41 -// VERSION_SWITCH_ON = 0x0001, //加载  
42 -// VERSION_SWITCH_OFF = 0x0000, //不加载  
43 -// }VersionLoadSwitch;  
44 -  
45 #define VERSION_SWITCH_ON 0x0001 //加载 27 #define VERSION_SWITCH_ON 0x0001 //加载
46 #define VERSION_SWITCH_OFF 0x0000 //不加载 28 #define VERSION_SWITCH_OFF 0x0000 //不加载
47 29
48 -// //设备名  
49 -// typedef enum DeviceName  
50 -// {  
51 -// JZ_H1E = 0x0011, //H1E  
52 -// JZ_H1T = 0x0016, //H1T  
53 -// JZ_U3 = 0x0017, //U3  
54 -// JZ_U3S = 0x0018, //U3S  
55 -// JZ_U3D = 0x0019, //U3D  
56 -// JZ_U30 = 0x001A, //U30  
57 -// JZ_H150S = 0x0013, //H150S  
58 -// JZ_H150T = 0x0015, //H150T  
59 -// JZ_H10 = 0x0012, //H10  
60 -// JZ_H10T = 0x0014, //H10T  
61 -// TF_A1 = 0x1010, //TF-A1  
62 -// JZ_C1 = 0x1011, //C1  
63 -  
64 -// }DeviceName;  
65 -  
66 //设备选择 30 //设备选择
67 #define JZ_H1E 0x0011 31 #define JZ_H1E 0x0011
68 32
  1 +/**
  2 + ********************************************************************
  3 + * @file JZsdk_typedef.h
  4 + * 用于记录各类码的表
  5 + *
  6 + *********************************************************************
  7 + */
  8 +
  9 +/* Define to prevent recursive inclusion 避免重定义 -------------------------------------*/
  10 +#ifndef JZSDK_TYPEDEF_H
  11 +#define JZSDK_TYPEDEF_H
  12 +
  13 +/* Includes ------------------------------------------------------------------*/
  14 +#include "../JZsdk_typedef/JZsdk_typedef.h"
  15 +
  16 +#ifdef __cplusplus
  17 +extern "C" {
  18 +#endif
  19 +
  20 +
  21 +/* Exported constants --------------------------------------------------------*/
  22 +/* 常亮定义*/
  23 +
  24 +/* Exported macro ------------------------------------------------------------*/
  25 +
  26 +
  27 +/* Exported types ------------------------------------------------------------*/
  28 +
  29 +
  30 +/* Exported functions --------------------------------------------------------*/
  31 +
  32 +#ifdef __cplusplus
  33 +}
  34 +#endif
  35 +
  36 +#endif
  37 +
  38 +
1 -#include <stdint.h>  
2 -#include <stdbool.h>  
3 -#include <stddef.h>  
4 -#include <string.h>  
5 -#include <stdlib.h>  
6 -#include <stdio.h>  
7 -#include <string.h>  
8 -  
9 -#include "./JZsdk_Code.h"  
10 -  
11 - 1 +#include "./JZsdk_ReturnCode.h"
12 2
13 //获取返回码的信息 3 //获取返回码的信息
14 const char* JZsdk_GetReturnCodeMessage(T_JZsdkReturnCode ReturnCode) 4 const char* JZsdk_GetReturnCodeMessage(T_JZsdkReturnCode ReturnCode)
@@ -13,8 +13,7 @@ @@ -13,8 +13,7 @@
13 #define JZSDK_RETURNCODE_H 13 #define JZSDK_RETURNCODE_H
14 14
15 /* Includes ------------------------------------------------------------------*/ 15 /* Includes ------------------------------------------------------------------*/
16 -#include <stdint.h>  
17 -#include "JZsdk_ErrorCode.h" 16 +#include "../JZsdk_typedef/JZsdk_typedef.h"
18 17
19 #ifdef __cplusplus 18 #ifdef __cplusplus
20 extern "C" { 19 extern "C" {
@@ -30,21 +29,7 @@ extern "C" { @@ -30,21 +29,7 @@ extern "C" {
30 29
31 30
32 /* Exported types ------------------------------------------------------------*/ 31 /* Exported types ------------------------------------------------------------*/
33 -//重定义一个返回码  
34 -typedef uint64_t T_JZsdkReturnCode;  
35 -typedef uint8_t U8_t;  
36 -typedef uint16_t U16_t;  
37 -typedef uint32_t U32_t;  
38 -typedef uint64_t U64_t;  
39 -  
40 -// typedef unsigned long T_JZsdkReturnCode;  
41 -// typedef unsigned char U8_t;  
42 -// typedef unsigned short U16_t;  
43 -// typedef unsigned int U32_t;  
44 -// typedef unsigned long U64_t;  
45 -  
46 -typedef double F64_t;  
47 -typedef float F32_t; 32 +
48 33
49 /* Exported functions --------------------------------------------------------*/ 34 /* Exported functions --------------------------------------------------------*/
50 const char* JZsdk_GetReturnCodeMessage(T_JZsdkReturnCode ReturnCode); 35 const char* JZsdk_GetReturnCodeMessage(T_JZsdkReturnCode ReturnCode);
@@ -24,7 +24,9 @@ extern "C" { @@ -24,7 +24,9 @@ extern "C" {
24 typedef enum { 24 typedef enum {
25 JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS = 0x0000, 25 JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS = 0x0000,
26 JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE = 0x0001, 26 JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE = 0x0001,
  27 + JZ_ERROR_SYSTEM_MODULE_CODE_HARDLY_FAILURE = 0x0003, //严重错误
27 JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER = 0x0002, //文件指针错误 28 JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER = 0x0002, //文件指针错误
  29 + JZ_ERROR_SYSTEM_MODULE_CODE_MEMORY_ALLOC_FAILED = 0x0004, //内存分配失败
28 } JZ_SYSTEM_Code; 30 } JZ_SYSTEM_Code;
29 31
30 typedef enum { 32 typedef enum {
  1 +/**
  2 + ********************************************************************
  3 + * @file JZsdk_typedef.h
  4 + * 用于记录各类码的表
  5 + *
  6 + *********************************************************************
  7 + */
  8 +
  9 +/* Define to prevent recursive inclusion 避免重定义 -------------------------------------*/
  10 +#ifndef JZSDK_TYPEDEF_H
  11 +#define JZSDK_TYPEDEF_H
  12 +
  13 +/* Includes ------------------------------------------------------------------*/
  14 +#include <stdint.h>
  15 +#include <stdbool.h>
  16 +#include <stddef.h>
  17 +#include <string.h>
  18 +#include <stdlib.h>
  19 +#include <stdio.h>
  20 +#include <string.h>
  21 +
  22 +#ifdef __cplusplus
  23 +extern "C" {
  24 +#endif
  25 +
  26 +#include "./JZsdk_ErrorCodeDef.h"
  27 +#include "./JZsdk_FileTypeDef.h"
  28 +
  29 +/* Exported constants --------------------------------------------------------*/
  30 +/* 常亮定义*/
  31 +
  32 +
  33 +/* Exported macro ------------------------------------------------------------*/
  34 +//重定义一个返回码
  35 +typedef uint64_t T_JZsdkReturnCode;
  36 +typedef uint8_t U8_t;
  37 +typedef uint16_t U16_t;
  38 +typedef uint32_t U32_t;
  39 +typedef uint64_t U64_t;
  40 +
  41 +// typedef unsigned long T_JZsdkReturnCode;
  42 +// typedef unsigned char U8_t;
  43 +// typedef unsigned short U16_t;
  44 +// typedef unsigned int U32_t;
  45 +// typedef unsigned long U64_t;
  46 +
  47 +typedef double F64_t;
  48 +typedef float F32_t;
  49 +
  50 +
  51 +//线程权柄
  52 +typedef void *T_JZTaskHandle;
  53 +//互斥锁权柄
  54 +typedef void *T_JZsdkMutexHandle;
  55 +//信号量权柄
  56 +typedef void *T_JZsdkSemaHandle;
  57 +
  58 +/* Exported types ------------------------------------------------------------*/
  59 +
  60 +
  61 +/* Exported functions --------------------------------------------------------*/
  62 +
  63 +#ifdef __cplusplus
  64 +}
  65 +#endif
  66 +
  67 +#endif
  68 +
  69 +
1 -#include <stdio.h>  
2 -#include "JZsdk_Delay.h"  
3 -#include <unistd.h>  
4 -  
5 -/*  
6 -* 用于延时（粗略）  
7 -* 需要优化  
8 -*/  
9 -int delayUs(unsigned long msec)  
10 -{  
11 - usleep(msec);  
12 -}  
13 -  
14 -/*  
15 -* 用于延时（粗略）  
16 -* 需要优化  
17 -*/  
18 -int delayMs(unsigned long msec)  
19 -{  
20 - usleep(msec * 1000);  
21 -}  
22 -  
23 -/*  
24 -* 用于延时（粗略）  
25 -* 需要优化  
26 -*/  
27 -int delayS(unsigned long sec)  
28 -{  
29 - delayMs(sec * 1000);  
30 -}  
@@ -13,7 +13,7 @@ @@ -13,7 +13,7 @@
13 #define CHECK_SUM_H 13 #define CHECK_SUM_H
14 14
15 /* Includes ------------------------------------------------------------------*/ 15 /* Includes ------------------------------------------------------------------*/
16 -#include "../../JZsdk_Code/JZsdk_Code.h" 16 +#include "JZsdk_Base/JZsdk_Code/JZsdk_Code.h"
17 17
18 #ifdef __cplusplus 18 #ifdef __cplusplus
19 extern "C" { 19 extern "C" {
@@ -13,7 +13,7 @@ @@ -13,7 +13,7 @@
13 #define JZSDK_CHECK_SUM_H 13 #define JZSDK_CHECK_SUM_H
14 14
15 /* Includes ------------------------------------------------------------------*/ 15 /* Includes ------------------------------------------------------------------*/
16 -#include "../../JZsdk_Code/JZsdk_Code.h" 16 +#include "JZsdk_Base/JZsdk_Code/JZsdk_Code.h"
17 17
18 #ifdef __cplusplus 18 #ifdef __cplusplus
19 extern "C" { 19 extern "C" {
1 #include <stdio.h> 1 #include <stdio.h>
2 -#include "JZsdk_FileSystm.h" 2 +#include "./JZsdk_FileSystm.h"
3 #include <stdlib.h> 3 #include <stdlib.h>
4 #include <stdbool.h> 4 #include <stdbool.h>
5 #include <string.h> 5 #include <string.h>
@@ -446,3 +446,16 @@ T_JZsdkReturnCode JZsdk_Fs_ReadFileSize(const unsigned char* FilePath, int *File @@ -446,3 +446,16 @@ T_JZsdkReturnCode JZsdk_Fs_ReadFileSize(const unsigned char* FilePath, int *File
446 446
447 return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS; 447 return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
448 } 448 }
  449 +
  450 +
  451 +/**************
  452 + *
  453 + * 进行一次系统的保存
  454 + *
  455 + *
  456 + * *****************/
  457 +T_JZsdkReturnCode JZsdk_Sync()
  458 +{
  459 + sync();
  460 + return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
  461 +}
@@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@
11 #define JZSDK_FILESYSTEM_H 11 #define JZSDK_FILESYSTEM_H
12 12
13 /* Includes ------------------------------------------------------------------*/ 13 /* Includes ------------------------------------------------------------------*/
14 -#include "../JZsdk_Code/JZsdk_Code.h" 14 +#include "JZsdk_Base/JZsdk_Code/JZsdk_Code.h"
15 #include "./JZsdk_FS_Standards.h" 15 #include "./JZsdk_FS_Standards.h"
16 16
17 #ifdef __cplusplus 17 #ifdef __cplusplus
@@ -39,6 +39,7 @@ T_JZsdkReturnCode JZsdk_Fs_ReadFileSize(const unsigned char* FilePath, int *File @@ -39,6 +39,7 @@ T_JZsdkReturnCode JZsdk_Fs_ReadFileSize(const unsigned char* FilePath, int *File
39 T_JZsdkReturnCode JZsdk_copy_file_byC(const char* source_path, const char* dest_path); 39 T_JZsdkReturnCode JZsdk_copy_file_byC(const char* source_path, const char* dest_path);
40 T_JZsdkReturnCode JZsdk_RunSystemCmd_ReturnResult(char *systemCmd, unsigned int *result); 40 T_JZsdkReturnCode JZsdk_RunSystemCmd_ReturnResult(char *systemCmd, unsigned int *result);
41 T_JZsdkReturnCode JZsdk_RunSystemCmd_ReturnResult_Str(char *systemCmd, unsigned char *str); 41 T_JZsdkReturnCode JZsdk_RunSystemCmd_ReturnResult_Str(char *systemCmd, unsigned char *str);
  42 +T_JZsdkReturnCode JZsdk_Sync();
42 43
43 #ifdef __cplusplus 44 #ifdef __cplusplus
44 } 45 }
@@ -3,9 +3,7 @@ @@ -3,9 +3,7 @@
3 #include <stdbool.h> 3 #include <stdbool.h>
4 #include <string.h> 4 #include <string.h>
5 5
6 -#include "JZsdkLib.h"  
7 -  
8 - 6 +#include "./JZsdk_MemoryAdapter.h"
9 7
10 /********************************** 8 /**********************************
11 * 9 *
@@ -55,3 +53,17 @@ T_JZsdkReturnCode JZsdk_Free(void *ptr) @@ -55,3 +53,17 @@ T_JZsdkReturnCode JZsdk_Free(void *ptr)
55 53
56 return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS; 54 return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
57 } 55 }
  56 +
  57 +
  58 +
  59 +void *JZsdk_Osal_Malloc(U32_t size)
  60 +{
  61 + return malloc(size);
  62 +}
  63 +
  64 +void JZsdk_Osal_Free(void *ptr)
  65 +{
  66 + free(ptr);
  67 +}
  68 +
  69 +
@@ -11,7 +11,7 @@ @@ -11,7 +11,7 @@
11 #define JZSDK_MEMORY_ADAPTER_H 11 #define JZSDK_MEMORY_ADAPTER_H
12 12
13 /* Includes ------------------------------------------------------------------*/ 13 /* Includes ------------------------------------------------------------------*/
14 -#include "../JZsdk_Code/JZsdk_Code.h" 14 +#include "JZsdk_Base/JZsdk_Code/JZsdk_Code.h"
15 15
16 #ifdef __cplusplus 16 #ifdef __cplusplus
17 extern "C" { 17 extern "C" {
@@ -26,6 +26,8 @@ extern "C" { @@ -26,6 +26,8 @@ extern "C" {
26 /* Exported functions --------------------------------------------------------*/ 26 /* Exported functions --------------------------------------------------------*/
27 T_JZsdkReturnCode JZsdk_Malloc(void **ptr, unsigned int size); 27 T_JZsdkReturnCode JZsdk_Malloc(void **ptr, unsigned int size);
28 T_JZsdkReturnCode JZsdk_Free(void *ptr); 28 T_JZsdkReturnCode JZsdk_Free(void *ptr);
  29 +void *JZsdk_Osal_Malloc(U32_t size);
  30 +void JZsdk_Osal_Free(void *ptr);
29 31
30 #ifdef __cplusplus 32 #ifdef __cplusplus
31 } 33 }
  1 +#include <stdio.h>
  2 +#include <stdlib.h>
  3 +#include <pthread.h>
  4 +
  5 +#include "./JZsdk_Mutex.h"
  6 +
  7 +/**
  8 + * @brief Declare the mutex container, initialize the mutex, and
  9 + * create mutex ID.
  10 + * @param mutex: pointer to the created mutex ID.
  11 + * @return an enum that represents a status of PSDK
  12 + */
  13 +T_JZsdkReturnCode JZsdk_Osal_MutexCreate(T_JZsdkMutexHandle *mutex)
  14 +{
  15 + int result;
  16 +
  17 + if (!mutex)
  18 + {
  19 + return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
  20 + }
  21 +
  22 + *mutex = malloc(sizeof(pthread_mutex_t));
  23 + if (*mutex == NULL)
  24 + {
  25 + return JZ_ERROR_SYSTEM_MODULE_CODE_MEMORY_ALLOC_FAILED;
  26 + }
  27 +
  28 + result = pthread_mutex_init(*mutex, NULL);
  29 + if (result != 0)
  30 + {
  31 + return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
  32 + }
  33 +
  34 + return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
  35 +}
  36 +
  37 +
  38 +
  39 +/**
  40 + * @brief Delete the created mutex.
  41 + * @param mutex: pointer to the created mutex ID.
  42 + * @return an enum that represents a status of PSDK
  43 + */
  44 +T_JZsdkReturnCode JZsdk_Osal_MutexDestroy(T_JZsdkMutexHandle mutex)
  45 +{
  46 + int result = 0;
  47 +
  48 + if (!mutex)
  49 + {
  50 + return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
  51 + }
  52 +
  53 + result = pthread_mutex_destroy(mutex);
  54 + if (result != 0)
  55 + {
  56 + return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
  57 + }
  58 +
  59 + free(mutex);
  60 +
  61 + return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
  62 +}
  63 +
  64 +/**
  65 + * @brief Acquire and lock the mutex when peripheral access is required
  66 + * @param mutex: pointer to the created mutex ID.
  67 + * @return an enum that represents a status of PSDK
  68 + */
  69 +T_JZsdkReturnCode JZsdk_Osal_MutexLock(T_JZsdkMutexHandle mutex)
  70 +{
  71 + int result = 0;
  72 +
  73 + if (!mutex)
  74 + {
  75 + return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
  76 + }
  77 +
  78 + result = pthread_mutex_lock(mutex);
  79 + if (result != 0)
  80 + {
  81 + return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
  82 + }
  83 +
  84 + return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
  85 +}
  86 +
  87 +
  88 +
  89 +/**
  90 + * @brief Unlock and release the mutex, when done with the peripheral access.
  91 + * @param mutex: pointer to the created mutex ID.
  92 + * @return an enum that represents a status of PSDK
  93 + */
  94 +T_JZsdkReturnCode JZsdk_Osal_MutexUnlock(T_JZsdkMutexHandle mutex)
  95 +{
  96 + int result = 0;
  97 +
  98 + if (!mutex)
  99 + {
  100 + return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
  101 + }
  102 +
  103 + result = pthread_mutex_unlock(mutex);
  104 + if (result != 0)
  105 + {
  106 + return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
  107 + }
  108 +
  109 + return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
  110 +}
1 /** 1 /**
2 ******************************************************************** 2 ********************************************************************
3 - * @file JZsdk_FileSystem.h  
4 - * 用于文件系统操作 3 + * @file JZsdk_Mutex.h
  4 + * JZsdk_Mutex.c 的头文件
5 * 5 *
6 ********************************************************************* 6 *********************************************************************
7 */ 7 */
8 8
9 /* Define to prevent recursive inclusion 避免重定义 -------------------------------------*/ 9 /* Define to prevent recursive inclusion 避免重定义 -------------------------------------*/
10 -#ifndef JZSDK_DELAY_H  
11 -#define JZSDK_DELAY_H 10 +#ifndef JZSDK_MUTEX_H
  11 +#define JZSDK_MUTEX_H
12 12
13 /* Includes ------------------------------------------------------------------*/ 13 /* Includes ------------------------------------------------------------------*/
  14 +#include "JZsdk_Base/JZsdk_Code/JZsdk_Code.h"
14 15
15 #ifdef __cplusplus 16 #ifdef __cplusplus
16 extern "C" { 17 extern "C" {
@@ -19,14 +20,17 @@ extern "C" { @@ -19,14 +20,17 @@ extern "C" {
19 /* Exported constants --------------------------------------------------------*/ 20 /* Exported constants --------------------------------------------------------*/
20 /* 常亮定义*/ 21 /* 常亮定义*/
21 22
  23 +/* Exported macro ------------------------------------------------------------*/
22 24
23 /* Exported types ------------------------------------------------------------*/ 25 /* Exported types ------------------------------------------------------------*/
24 26
25 27
26 /* Exported functions --------------------------------------------------------*/ 28 /* Exported functions --------------------------------------------------------*/
27 -int delayMs(unsigned long msec);  
28 -int delayS(unsigned long sec);  
29 -int delayUs(unsigned long msec); 29 +T_JZsdkReturnCode JZsdk_Osal_MutexCreate(T_JZsdkMutexHandle *mutex);
  30 +T_JZsdkReturnCode JZsdk_Osal_MutexDestroy(T_JZsdkMutexHandle mutex);
  31 +T_JZsdkReturnCode JZsdk_Osal_MutexLock(T_JZsdkMutexHandle mutex);
  32 +T_JZsdkReturnCode JZsdk_Osal_MutexUnlock(T_JZsdkMutexHandle mutex);
  33 +
30 34
31 #ifdef __cplusplus 35 #ifdef __cplusplus
32 } 36 }
1 -// #include "../JZsdk_Code/JZsdk_Code.h"  
2 -// #include "./JZsdk_Osal.h" 1 +#include "../JZsdk_Code/JZsdk_Code.h"
  2 +#include "./JZsdk_Osal.h"
3 3
4 -// T_JZsdkReturnCode JZsdk_Osal_TaskCreate(const char *name, void *(*taskFunc)(void *), uint32_t stackSize, void *arg,  
5 -// T_JzTaskHandle *task) 4 +
  5 +
  6 +
  7 +static T_JZsdkOsalHandler* g_osalHandler = NULL;
  8 +
  9 +static T_JZsdkReturnCode JZsdk_Platform_RegOsalHandler(const T_JZsdkOsalHandler *osalHandler)
  10 +{
  11 + g_osalHandler = (T_JZsdkOsalHandler*)osalHandler; // 存储传入的 OSAL 处理器
  12 +
  13 + return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
  14 +}
  15 +
  16 +T_JZsdkOsalHandler *JZsdk_Platform_GetOsalHandler(void)
  17 +{
  18 + return g_osalHandler; // 返回已注册的 OSAL 处理器
  19 +}
  20 +
  21 +T_JZsdkReturnCode JZsdk_OsalInit()
  22 +{
  23 + T_JZsdkOsalHandler osalHandler = {
  24 + .TaskCreate = JZsdk_Osal_TaskCreate,
  25 + .TaskDestroy = JZsdk_Osal_TaskDestroy,
  26 + .TaskSleepMs = delayMs,
  27 + .MutexCreate= JZsdk_Osal_MutexCreate,
  28 + .MutexDestroy = JZsdk_Osal_MutexDestroy,
  29 + .MutexLock = JZsdk_Osal_MutexLock,
  30 + .MutexUnlock = JZsdk_Osal_MutexUnlock,
  31 + .SemaphoreCreate = JZsdk_Osal_SemaphoreCreate,
  32 + .SemaphoreDestroy = JZsdk_Osal_SemaphoreDestroy,
  33 + .SemaphoreWait = JZsdk_Osal_SemaphoreWait,
  34 + .SemaphoreTimedWait = JZsdk_Osal_SemaphoreTimedWait,
  35 + .SemaphorePost = JZsdk_Osal_SemaphorePost,
  36 + .Malloc = JZsdk_Osal_Malloc,
  37 + .Free = JZsdk_Osal_Free,
  38 + .GetTimeMs = JZsdk_Osal_GetTimeMs,
  39 + .GetTimeUs = JZsdk_Osal_GetTimeUs,
  40 + .GetRandomNum = JZsdk_Osal_GetRandomNum,
  41 + };
  42 +
  43 + JZsdk_Platform_RegOsalHandler(&osalHandler);
  44 +
  45 + return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
  46 +}
@@ -13,6 +13,14 @@ @@ -13,6 +13,14 @@
13 /* Includes ------------------------------------------------------------------*/ 13 /* Includes ------------------------------------------------------------------*/
14 #include "../JZsdk_Code/JZsdk_Code.h" 14 #include "../JZsdk_Code/JZsdk_Code.h"
15 15
  16 +#include "./JZsdk_CheckSum/JZsdk_CheckSum.h"
  17 +#include "./JZsdk_FileSystm/JZsdk_FileSystm.h"
  18 +#include "./JZsdk_MemoryAdapter/JZsdk_MemoryAdapter.h"
  19 +#include "./JZsdk_Mutex/JZsdk_Mutex.h"
  20 +#include "./JZsdk_Semaphore/JZsdk_Semaphore.h"
  21 +#include "./JZsdk_Task/JZsdk_Task.h"
  22 +#include "./JZsdk_Timer/JZsdk_Timer.h"
  23 +
16 #ifdef __cplusplus 24 #ifdef __cplusplus
17 extern "C" { 25 extern "C" {
18 #endif 26 #endif
@@ -20,12 +28,60 @@ extern "C" { @@ -20,12 +28,60 @@ extern "C" {
20 /* Exported constants --------------------------------------------------------*/ 28 /* Exported constants --------------------------------------------------------*/
21 /* 常亮定义*/ 29 /* 常亮定义*/
22 30
23 -typedef void *T_JzTaskHandle; 31 +/****************
  32 + *
  33 + * osal权柄
  34 + *
  35 + *
  36 + * ******************/
  37 +typedef struct {
  38 + T_JZsdkReturnCode (*TaskCreate)(const char *name, void *(*taskFunc)(void *),
  39 + unsigned int stackSize, void *arg, T_JZTaskHandle *task);
  40 +
  41 + T_JZsdkReturnCode (*TaskDestroy)(T_JZTaskHandle task);
  42 +
  43 + T_JZsdkReturnCode (*TaskSleepMs)(U32_t timeMs);
  44 +
  45 + T_JZsdkReturnCode (*MutexCreate)(T_JZsdkMutexHandle *mutex);
  46 +
  47 + T_JZsdkReturnCode (*MutexDestroy)(T_JZsdkMutexHandle mutex);
  48 +
  49 + T_JZsdkReturnCode (*MutexLock)(T_JZsdkMutexHandle mutex);
  50 +
  51 + T_JZsdkReturnCode (*MutexUnlock)(T_JZsdkMutexHandle mutex);
  52 +
  53 + T_JZsdkReturnCode (*SemaphoreCreate)(U32_t initValue, T_JZsdkSemaHandle *semaphore);
  54 +
  55 + T_JZsdkReturnCode (*SemaphoreDestroy)(T_JZsdkSemaHandle semaphore);
  56 +
  57 + T_JZsdkReturnCode (*SemaphoreWait)(T_JZsdkSemaHandle semaphore);
  58 +
  59 + T_JZsdkReturnCode (*SemaphoreTimedWait)(T_JZsdkSemaHandle semaphore, U32_t waitTimeMs);
  60 +
  61 + T_JZsdkReturnCode (*SemaphorePost)(T_JZsdkSemaHandle semaphore);
  62 +
  63 + T_JZsdkReturnCode (*GetTimeMs)(U32_t *ms);
  64 +
  65 + T_JZsdkReturnCode (*GetTimeUs)(U64_t *us);
  66 +
  67 + T_JZsdkReturnCode (*GetRandomNum)(U16_t *randomNum);
  68 +
  69 + void *(*Malloc)(U32_t size);
  70 +
  71 + void (*Free)(void *ptr);
  72 +} T_JZsdkOsalHandler;
  73 +
  74 +
  75 +
  76 +/* Exported macro ------------------------------------------------------------*/
  77 +
24 78
25 /* Exported types ------------------------------------------------------------*/ 79 /* Exported types ------------------------------------------------------------*/
26 80
27 81
28 /* Exported functions --------------------------------------------------------*/ 82 /* Exported functions --------------------------------------------------------*/
  83 +T_JZsdkReturnCode JZsdk_OsalInit();
  84 +T_JZsdkOsalHandler *JZsdk_Platform_GetOsalHandler(void);
29 85
30 86
31 #ifdef __cplusplus 87 #ifdef __cplusplus
  1 +#include <stdio.h>
  2 +#include <stdlib.h>
  3 +#include <pthread.h>
  4 +#include <semaphore.h>
  5 +#include <sys/time.h>
  6 +
  7 +#include "./JZsdk_Semaphore.h"
  8 +
  9 +/**
  10 + * @brief Declare the semaphore container, initialize the semaphore, and
  11 + * create semaphore ID.
  12 + * @param semaphore: pointer to the created semaphore ID.
  13 + * @param initValue: initial value of semaphore.
  14 + * @return an enum that represents a status of PSDK
  15 + */
  16 +T_JZsdkReturnCode JZsdk_Osal_SemaphoreCreate(U32_t initValue, T_JZsdkSemaHandle *semaphore)
  17 +{
  18 + int result;
  19 +
  20 + *semaphore = malloc(sizeof(sem_t));
  21 + if (*semaphore == NULL)
  22 + {
  23 + return JZ_ERROR_SYSTEM_MODULE_CODE_MEMORY_ALLOC_FAILED;
  24 + }
  25 +
  26 + result = sem_init(*semaphore, 0, (unsigned int) initValue);
  27 + if (result != 0)
  28 + {
  29 + return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
  30 + }
  31 +
  32 + return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
  33 +}
  34 +
  35 +
  36 +/**
  37 + * @brief Delete the created semaphore.
  38 + * @param semaphore: pointer to the created semaphore ID.
  39 + * @return an enum that represents a status of PSDK
  40 + */
  41 +T_JZsdkReturnCode JZsdk_Osal_SemaphoreDestroy(T_JZsdkSemaHandle semaphore)
  42 +{
  43 + int result;
  44 +
  45 + result = sem_destroy((sem_t *) semaphore);
  46 + if (result != 0)
  47 + {
  48 + return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
  49 + }
  50 +
  51 + free(semaphore);
  52 +
  53 + return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
  54 +}
  55 +
  56 +
  57 +/**
  58 + * @brief Wait the semaphore until token becomes available.
  59 + * @param semaphore: pointer to the created semaphore ID.
  60 + * @return an enum that represents a status of PSDK
  61 + */
  62 +T_JZsdkReturnCode JZsdk_Osal_SemaphoreWait(T_JZsdkSemaHandle semaphore)
  63 +{
  64 + int result;
  65 +
  66 + result = sem_wait(semaphore);
  67 + if (result != 0)
  68 + {
  69 + return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
  70 + }
  71 +
  72 + return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
  73 +}
  74 +
  75 +
  76 +/**
  77 + * @brief Wait the semaphore until token becomes available.
  78 + * @param semaphore: pointer to the created semaphore ID.
  79 + * @param waitTime: timeout value of waiting semaphore, unit: millisecond.
  80 + * @return an enum that represents a status of PSDK
  81 + */
  82 +T_JZsdkReturnCode JZsdk_Osal_SemaphoreTimedWait(T_JZsdkSemaHandle semaphore, U32_t waitTime)
  83 +{
  84 + int result;
  85 + struct timespec semaphoreWaitTime;
  86 + struct timeval systemTime;
  87 +
  88 + gettimeofday(&systemTime, NULL);
  89 +
  90 + systemTime.tv_usec += waitTime * 1000;
  91 + if (systemTime.tv_usec >= 1000000)
  92 + {
  93 + systemTime.tv_sec += systemTime.tv_usec / 1000000;
  94 + systemTime.tv_usec %= 1000000;
  95 + }
  96 +
  97 + semaphoreWaitTime.tv_sec = systemTime.tv_sec;
  98 + semaphoreWaitTime.tv_nsec = systemTime.tv_usec * 1000;
  99 +
  100 + result = sem_timedwait(semaphore, &semaphoreWaitTime);
  101 + if (result != 0)
  102 + {
  103 + return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
  104 + }
  105 +
  106 + return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
  107 +}
  108 +
  109 +
  110 +
  111 +/**
  112 + * @brief Release the semaphore token.
  113 + * @param semaphore: pointer to the created semaphore ID.
  114 + * @return an enum that represents a status of PSDK
  115 + */
  116 +T_JZsdkReturnCode JZsdk_Osal_SemaphorePost(T_JZsdkSemaHandle semaphore)
  117 +{
  118 + int result;
  119 +
  120 + result = sem_post(semaphore);
  121 + if (result != 0)
  122 + {
  123 + return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
  124 + }
  125 +
  126 + return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
  127 +}
  1 +/**
  2 + ********************************************************************
  3 + * @file JZsdk_Semaphore.h
  4 + * JZsdk_Semaphore.c 的头文件
  5 + *
  6 + *********************************************************************
  7 + */
  8 +
  9 +/* Define to prevent recursive inclusion 避免重定义 -------------------------------------*/
  10 +#ifndef JZSDK_SEMAPHORE_H
  11 +#define JZSDK_SEMAPHORE_H
  12 +
  13 +/* Includes ------------------------------------------------------------------*/
  14 +#include "JZsdk_Base/JZsdk_Code/JZsdk_Code.h"
  15 +
  16 +#ifdef __cplusplus
  17 +extern "C" {
  18 +#endif
  19 +
  20 +/* Exported constants --------------------------------------------------------*/
  21 +/* 常亮定义*/
  22 +
  23 +/* Exported macro ------------------------------------------------------------*/
  24 +
  25 +/* Exported types ------------------------------------------------------------*/
  26 +
  27 +
  28 +/* Exported functions --------------------------------------------------------*/
  29 +T_JZsdkReturnCode JZsdk_Osal_SemaphoreCreate(U32_t initValue, T_JZsdkSemaHandle *semaphore);
  30 +T_JZsdkReturnCode JZsdk_Osal_SemaphoreDestroy(T_JZsdkSemaHandle semaphore);
  31 +T_JZsdkReturnCode JZsdk_Osal_SemaphoreWait(T_JZsdkSemaHandle semaphore);
  32 +T_JZsdkReturnCode JZsdk_Osal_SemaphoreTimedWait(T_JZsdkSemaHandle semaphore, U32_t waitTime);
  33 +T_JZsdkReturnCode JZsdk_Osal_SemaphorePost(T_JZsdkSemaHandle semaphore);
  34 +
  35 +
  36 +#ifdef __cplusplus
  37 +}
  38 +#endif
  39 +
  40 +#endif
  41 +/************************ (C) COPYRIGHT DJI Innovations *******END OF FILE******/
  1 +#include <stdio.h>
  2 +#include <stdlib.h>
  3 +#include <pthread.h>
  4 +
  5 +#include "./JZsdk_Task.h"
  6 +
  7 +T_JZsdkReturnCode JZsdk_Osal_TaskCreate(const char *name, void *(*taskFunc)(void *), unsigned int stackSize, void *arg,
  8 + T_JZTaskHandle *task)
  9 +{
  10 + int result;
  11 + char nameDealed[16] = {0};
  12 +
  13 + //为任务句柄分配内存空间，大小为sizeof(pthread_t)。如果内存分配失败，则返回一个错误代码
  14 + *task = malloc(sizeof(pthread_t));
  15 + if (*task == NULL) {
  16 + return JZ_ERROR_SYSTEM_MODULE_CODE_MEMORY_ALLOC_FAILED;
  17 + }
  18 +
  19 + //使用pthread_create函数创建一个新的线程，传递给它任务函数指针taskFunc和参数arg。如果创建线程失败，则返回一个错误代码
  20 + result = pthread_create(*task, NULL, taskFunc, arg);
  21 + if (result != 0) {
  22 + return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
  23 + }
  24 +
  25 +
  26 + //如果任务名称name不为空，则将其拷贝到nameDealed字符数组中（最多拷贝sizeof(nameDealed) - 1个字符）。
  27 + if (name != NULL)
  28 + strncpy(nameDealed, name, sizeof(nameDealed) - 1);
  29 +
  30 + //使用pthread_setname_np函数将任务线程的名称设置为nameDealed。如果设置线程名称失败，则返回一个错误代码
  31 + result = pthread_setname_np(*(pthread_t *) *task, nameDealed);
  32 + if (result != 0) {
  33 + return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
  34 + }
  35 +
  36 +/*int pthread_setcanceltype(int type, int *oldtype);
  37 +```
  38 +
  39 +- `type`参数指定了取消类型，可以是以下两个值之一：
  40 + - `PTHREAD_CANCEL_DEFERRED`：线程将在下一个取消点取消。取消点是指线程可以响应取消请求的一些特定操作点，例如函数调用、线程等待等。线程将继续运行，直到到达取消点后才会被取消。
  41 + - `PTHREAD_CANCEL_ASYNCHRONOUS`：线程立即取消，不论是否在取消点。线程将立即终止执行，不会进行清理操作。这种取消类型可能导致资源泄漏和数据不一致，因此需要谨慎使用。
  42 +- `oldtype`参数是一个可选的输出参数，用于获取之前的取消类型。
  43 +
  44 +*/
  45 + pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
  46 +/*
  47 +- `state`参数指定了取消状态，可以是以下两个值之一：
  48 + - `PTHREAD_CANCEL_ENABLE`：线程可以接收取消请求。
  49 + - `PTHREAD_CANCEL_DISABLE`：线程忽略取消请求。
  50 +- `oldstate`参数是一个可选的输出参数，用于获取之前的取消状态。
  51 +
  52 +通过调用`pthread_setcancelstate`函数，您可以选择线程的取消状态。默认情况下，线程的取消状态是`PTHREAD_CANCEL_ENABLE`。*/
  53 + pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
  54 +
  55 + return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
  56 +
  57 +}
  58 +
  59 +
  60 +T_JZsdkReturnCode JZsdk_Osal_TaskDestroy(T_JZTaskHandle task)
  61 +{
  62 + pthread_cancel(*(pthread_t *) task);
  63 + free(task);
  64 +
  65 + return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
  66 +}
  1 +/**
  2 + ********************************************************************
  3 + * @file JZsdk_Task.h
  4 + * JZsdk_Task.c 的头文件
  5 + *
  6 + *********************************************************************
  7 + */
  8 +
  9 +/* Define to prevent recursive inclusion 避免重定义 -------------------------------------*/
  10 +#ifndef JZSDK_TASK_H
  11 +#define JZSDK_TASK_H
  12 +
  13 +/* Includes ------------------------------------------------------------------*/
  14 +#include "JZsdk_Base/JZsdk_Code/JZsdk_Code.h"
  15 +
  16 +#ifdef __cplusplus
  17 +extern "C" {
  18 +#endif
  19 +
  20 +/* Exported constants --------------------------------------------------------*/
  21 +/* 常亮定义*/
  22 +
  23 +/* Exported macro ------------------------------------------------------------*/
  24 +
  25 +/* Exported types ------------------------------------------------------------*/
  26 +
  27 +
  28 +/* Exported functions --------------------------------------------------------*/
  29 +T_JZsdkReturnCode JZsdk_Osal_TaskCreate(const char *name, void *(*taskFunc)(void *), unsigned int stackSize, void *arg,
  30 + T_JZTaskHandle *task);
  31 +
  32 +T_JZsdkReturnCode JZsdk_Osal_TaskDestroy(T_JZTaskHandle task);
  33 +
  34 +#ifdef __cplusplus
  35 +}
  36 +#endif
  37 +
  38 +#endif
  39 +/************************ (C) COPYRIGHT DJI Innovations *******END OF FILE******/
  1 +#include <sys/time.h> // 为了使用 gettimeofday 函数
  2 +#include <time.h> // 为了使用 time 函数
  3 +
  4 +#include "./JZsdk_TimeR.h"
  5 +
  6 +static U32_t s_localTimeMsOffset = 0;
  7 +static U64_t s_localTimeUsOffset = 0;
  8 +
  9 +
  10 +/**
  11 + * @brief Get the system time for ms.
  12 + * @return an uint32 that the time of system, uint:ms
  13 + */
  14 +T_JZsdkReturnCode JZsdk_Osal_GetTimeMs(U32_t *ms)
  15 +{
  16 + struct timeval time;
  17 +
  18 + gettimeofday(&time, NULL);
  19 + *ms = (time.tv_sec * 1000 + time.tv_usec / 1000);
  20 +
  21 + if (s_localTimeMsOffset == 0)
  22 + {
  23 + s_localTimeMsOffset = *ms;
  24 + } else {
  25 + *ms = *ms - s_localTimeMsOffset;
  26 + }
  27 +
  28 + return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
  29 +}
  30 +
  31 +T_JZsdkReturnCode JZsdk_Osal_GetTimeUs(U64_t *us)
  32 +{
  33 + struct timeval time;
  34 +
  35 + gettimeofday(&time, NULL);
  36 + *us = (time.tv_sec * 1000000 + time.tv_usec);
  37 +
  38 + if (s_localTimeUsOffset == 0) {
  39 + s_localTimeUsOffset = *us;
  40 + } else {
  41 + *us = *us - s_localTimeMsOffset;
  42 + }
  43 +
  44 + return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
  45 +}
  46 +
  47 +T_JZsdkReturnCode JZsdk_Osal_GetRandomNum(U16_t *randomNum)
  48 +{
  49 + srand(time(NULL));
  50 + *randomNum = random() % 65535;
  51 +
  52 + return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
  53 +}
  54 +
  55 +
  56 +/*
  57 +* 用于延时（粗略）
  58 +* 需要优化
  59 +*/
  60 +T_JZsdkReturnCode delayUs(U32_t msec)
  61 +{
  62 + usleep(msec);
  63 +
  64 + return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
  65 +}
  66 +
  67 +/*
  68 +* 用于延时（粗略）
  69 +* 需要优化
  70 +*/
  71 +T_JZsdkReturnCode delayMs(U32_t msec)
  72 +{
  73 + usleep(msec * 1000);
  74 +
  75 + return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
  76 +}
  77 +
  78 +/*
  79 +* 用于延时（粗略）
  80 +* 需要优化
  81 +*/
  82 +T_JZsdkReturnCode delayS(U32_t sec)
  83 +{
  84 + delayMs(sec * 1000);
  85 +
  86 + return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
  87 +}
  1 +/**
  2 + ********************************************************************
  3 + * @file JZsdk_Timer.h
  4 + * JZsdk_Timer.c 的头文件
  5 + *
  6 + *********************************************************************
  7 + */
  8 +
  9 +/* Define to prevent recursive inclusion 避免重定义 -------------------------------------*/
  10 +#ifndef JZSDK_TIMER_H
  11 +#define JZSDK_TIMER_H
  12 +
  13 +/* Includes ------------------------------------------------------------------*/
  14 +#include "JZsdk_Base/JZsdk_Code/JZsdk_Code.h"
  15 +
  16 +#ifdef __cplusplus
  17 +extern "C" {
  18 +#endif
  19 +
  20 +/* Exported constants --------------------------------------------------------*/
  21 +/* 常亮定义*/
  22 +
  23 +/* Exported macro ------------------------------------------------------------*/
  24 +
  25 +/* Exported types ------------------------------------------------------------*/
  26 +
  27 +
  28 +/* Exported functions --------------------------------------------------------*/
  29 +T_JZsdkReturnCode JZsdk_Osal_GetTimeMs(U32_t *ms);
  30 +T_JZsdkReturnCode JZsdk_Osal_GetTimeUs(U64_t *us);
  31 +T_JZsdkReturnCode JZsdk_Osal_GetRandomNum(U16_t *randomNum);
  32 +T_JZsdkReturnCode delayUs(U32_t msec);
  33 +T_JZsdkReturnCode delayMs(U32_t msec);
  34 +T_JZsdkReturnCode delayS(U32_t sec);
  35 +
  36 +
  37 +#ifdef __cplusplus
  38 +}
  39 +#endif
  40 +
  41 +#endif
  42 +/************************ (C) COPYRIGHT DJI Innovations *******END OF FILE******/
@@ -25,8 +25,11 @@ @@ -25,8 +25,11 @@
25 #include "JZsdk_Hal.h" 25 #include "JZsdk_Hal.h"
26 26
27 #if APP_VERSION == APP_PSDK 27 #if APP_VERSION == APP_PSDK
  28 +
28 #include "fc_subscription/test_fc_subscription.h" 29 #include "fc_subscription/test_fc_subscription.h"
  30 +
29 #endif 31 #endif
  32 +
30 #include "DeviceInfo/DeviceInfo.h" 33 #include "DeviceInfo/DeviceInfo.h"
31 34
32 #ifdef MEGAPHONE_CONFIG_STATUS_ON 35 #ifdef MEGAPHONE_CONFIG_STATUS_ON
@@ -7,19 +7,19 @@ @@ -7,19 +7,19 @@
7 #define VERSION_CHOOSE_H 7 #define VERSION_CHOOSE_H
8 #include "JZsdk_Base/JZsdk_Code/JZsdk_DeviceCode.h" 8 #include "JZsdk_Base/JZsdk_Code/JZsdk_DeviceCode.h"
9 //1~10行 除了D可以修改版本选择 禁止动任何东西 9 //1~10行 除了D可以修改版本选择 禁止动任何东西
10 -#define DEVICE_VERSION JZ_C1 10 +#define DEVICE_VERSION JZ_H10
11 11
12 //禁止修改行 选择是串口程序 还是 psdk程序 12 //禁止修改行 选择是串口程序 还是 psdk程序
13 -#define APP_VERSION APP_PSDK 13 +#define APP_VERSION APP_UART
14 14
15 //禁止修改行 板子型号 15 //禁止修改行 板子型号
16 #define PLATFORM_VERSION PLATFORM_V3S 16 #define PLATFORM_VERSION PLATFORM_V3S
17 17
18 //禁止修改行 串口连接程序的软件版本号 18 //禁止修改行 串口连接程序的软件版本号
19 -#define MAJOR_VERSION 0x01  
20 -#define MINOR_VERSION 0x03  
21 -#define MODIFY_VERSION 0x09  
22 -#define DEBUG_VERSION 0x07 19 +#define MAJOR_VERSION 0x00
  20 +#define MINOR_VERSION 0x00
  21 +#define MODIFY_VERSION 0x02
  22 +#define DEBUG_VERSION 0x12
23 23
24 //禁止修改行 滤波方式 24 //禁止修改行 滤波方式
25 #define FILTERING_TYPE HIGH_PASS_FILTERING 25 #define FILTERING_TYPE HIGH_PASS_FILTERING
@@ -59,6 +59,7 @@ T_JZsdkReturnCode JZsdk_HalUsbBulk_Init(void **index, int interfaceNum, int isUs @@ -59,6 +59,7 @@ T_JZsdkReturnCode JZsdk_HalUsbBulk_Init(void **index, int interfaceNum, int isUs
59 ret = libusb_init(NULL); 59 ret = libusb_init(NULL);
60 if (ret < 0) { 60 if (ret < 0) {
61 JZSDK_LOG_ERROR("init usb bulk failed, errno = %d", ret); 61 JZSDK_LOG_ERROR("init usb bulk failed, errno = %d", ret);
  62 +
62 return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE; 63 return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
63 } 64 }
64 65
@@ -147,6 +148,7 @@ T_JZsdkReturnCode JZsdk_HalUsbBulk_ReadData(void **index ,unsigned char *buf, un @@ -147,6 +148,7 @@ T_JZsdkReturnCode JZsdk_HalUsbBulk_ReadData(void **index ,unsigned char *buf, un
147 buf, len, &actualLen, LINUX_USB_BULK_TRANSFER_WAIT_FOREVER); 148 buf, len, &actualLen, LINUX_USB_BULK_TRANSFER_WAIT_FOREVER);
148 if (ret < 0) { 149 if (ret < 0) {
149 JZSDK_LOG_ERROR("Read usb bulk data failed, errno = %d", ret); 150 JZSDK_LOG_ERROR("Read usb bulk data failed, errno = %d", ret);
  151 + delayMs(100);
150 return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE; 152 return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
151 } 153 }
152 #endif 154 #endif
@@ -69,7 +69,7 @@ T_JZsdkReturnCode AudioDeal_Init() @@ -69,7 +69,7 @@ T_JZsdkReturnCode AudioDeal_Init()
69 AudioDeakInfo_index->FilterInfo = NULL; 69 AudioDeakInfo_index->FilterInfo = NULL;
70 FF_Filter_Init(AudioDeakInfo_index, 0x00); 70 FF_Filter_Init(AudioDeakInfo_index, 0x00);
71 71
72 - //初始化mp2音频流 72 + //初始化实时流
73 File_Stream_deal_Init(AV_CODEC_ID_MP2); 73 File_Stream_deal_Init(AV_CODEC_ID_MP2);
74 74
75 Audiodeal_status = JZ_FLAGCODE_ON; 75 Audiodeal_status = JZ_FLAGCODE_ON;
@@ -195,11 +195,20 @@ T_JZsdkReturnCode AudioDeal_Mp3DataInput(int In_Bitrate, unsigned char *buffer, @@ -195,11 +195,20 @@ T_JZsdkReturnCode AudioDeal_Mp3DataInput(int In_Bitrate, unsigned char *buffer,
195 //1、打开音频库的处理标志位，该标志可以重复打开，只有强制关闭音频时，需要关闭该标志 195 //1、打开音频库的处理标志位，该标志可以重复打开，只有强制关闭音频时，需要关闭该标志
196 AudioDeakInfo_index->AudioDeal_ResampleAndFilter_Execute_Flag = JZ_FLAGCODE_ON; 196 AudioDeakInfo_index->AudioDeal_ResampleAndFilter_Execute_Flag = JZ_FLAGCODE_ON;
197 197
198 - mp3_Stream_Interface_Mp3Data(AudioDeakInfo_index, In_Bitrate, buffer, bytesRead); 198 + T_JZsdkReturnCode ret = mp3_Stream_Interface_Mp3Data(AudioDeakInfo_index, In_Bitrate, buffer, bytesRead);
  199 + if (ret == JZ_ERROR_SYSTEM_MODULE_CODE_HARDLY_FAILURE)
  200 + {
  201 + return JZ_ERROR_SYSTEM_MODULE_CODE_HARDLY_FAILURE;
  202 + }
199 203
200 return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS; 204 return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
201 } 205 }
202 206
  207 +T_JZsdkReturnCode AudioDeal_Mp3DataStop()
  208 +{
  209 + mp3_Stream_Interface_Mp3Data_Stop(AudioDeakInfo_index);
  210 +}
  211 +
203 /******************* 212 /*******************
204 * 213 *
205 * 暂停播放 214 * 暂停播放
@@ -264,9 +273,6 @@ T_JZsdkReturnCode AudioDeal_StopDeal() @@ -264,9 +273,6 @@ T_JZsdkReturnCode AudioDeal_StopDeal()
264 //清空alsa里的缓冲区 273 //清空alsa里的缓冲区
265 Alsa_DropPcm(AudioDeakInfo_index); 274 Alsa_DropPcm(AudioDeakInfo_index);
266 275
267 - //清空mp3音频流  
268 - Stream_Player_Stop(AudioDeakInfo_index);  
269 -  
270 while (AudioDeakInfo_index->AudioDeal_Alsa_Finish_Flag != JZ_FLAGCODE_OFF) 276 while (AudioDeakInfo_index->AudioDeal_Alsa_Finish_Flag != JZ_FLAGCODE_OFF)
271 { 277 {
272 delayMs(1); 278 delayMs(1);
@@ -99,6 +99,7 @@ T_JZsdkReturnCode AudioDeal_Mp3DataInput(int In_Bitrate, unsigned char *buffer, @@ -99,6 +99,7 @@ T_JZsdkReturnCode AudioDeal_Mp3DataInput(int In_Bitrate, unsigned char *buffer,
99 T_JZsdkReturnCode AudioDeal_PauseAndContinuePlay(int status); 99 T_JZsdkReturnCode AudioDeal_PauseAndContinuePlay(int status);
100 T_JZsdkReturnCode Get_AudioDealStatus(); 100 T_JZsdkReturnCode Get_AudioDealStatus();
101 T_JZsdkReturnCode AudioDeal_SetFilterMode(int mode); 101 T_JZsdkReturnCode AudioDeal_SetFilterMode(int mode);
  102 +T_JZsdkReturnCode AudioDeal_Mp3DataStop();
102 103
103 #ifdef __cplusplus 104 #ifdef __cplusplus
104 } 105 }
@@ -30,9 +30,8 @@ int PCM_PooL_Interface_PcmData(struct AudioDealInfo *AD_Info,unsigned int in_sam @@ -30,9 +30,8 @@ int PCM_PooL_Interface_PcmData(struct AudioDealInfo *AD_Info,unsigned int in_sam
30 int PCM_PooL_Interface_PcmData_WithoutReply(struct AudioDealInfo *AD_Info,unsigned int in_sampleRate, AVChannelLayout in_ch_layout, enum AVSampleFormat in_format , unsigned char* data, int dataSize); 30 int PCM_PooL_Interface_PcmData_WithoutReply(struct AudioDealInfo *AD_Info,unsigned int in_sampleRate, AVChannelLayout in_ch_layout, enum AVSampleFormat in_format , unsigned char* data, int dataSize);
31 T_JZsdkReturnCode AudioFile_Stream_Interface_PcmData(struct AudioDealInfo *AD_Info, AVFrame *frame); 31 T_JZsdkReturnCode AudioFile_Stream_Interface_PcmData(struct AudioDealInfo *AD_Info, AVFrame *frame);
32 T_JZsdkReturnCode mp3_Stream_Interface_Mp3Data(struct AudioDealInfo *AD_Info, unsigned int in_sampleRate, unsigned char *data, int dataSize); 32 T_JZsdkReturnCode mp3_Stream_Interface_Mp3Data(struct AudioDealInfo *AD_Info, unsigned int in_sampleRate, unsigned char *data, int dataSize);
33 -  
34 T_JZsdkReturnCode File_Stream_deal_Init(enum AVCodecID id); 33 T_JZsdkReturnCode File_Stream_deal_Init(enum AVCodecID id);
35 -T_JZsdkReturnCode Stream_Player_Stop(struct AudioDealInfo *AD_Info); 34 +T_JZsdkReturnCode mp3_Stream_Interface_Mp3Data_Stop(struct AudioDealInfo *AD_Info);
36 35
37 #ifdef __cplusplus 36 #ifdef __cplusplus
38 } 37 }
@@ -23,60 +23,48 @@ T_JZsdkReturnCode Stream_Player_decode(struct AudioDealInfo *AD_Info, AVCodecCon @@ -23,60 +23,48 @@ T_JZsdkReturnCode Stream_Player_decode(struct AudioDealInfo *AD_Info, AVCodecCon
23 23
24 T_JZsdkReturnCode File_Stream_deal_Init(enum AVCodecID id) 24 T_JZsdkReturnCode File_Stream_deal_Init(enum AVCodecID id)
25 { 25 {
26 - //注册包  
27 pkt = av_packet_alloc(); 26 pkt = av_packet_alloc();
28 if(!pkt) 27 if(!pkt)
29 { 28 {
30 JZSDK_LOG_ERROR("av_packet_alloc failed."); 29 JZSDK_LOG_ERROR("av_packet_alloc failed.");
31 } 30 }
32 31
33 - //寻找解码器  
34 codec = avcodec_find_decoder(id); 32 codec = avcodec_find_decoder(id);
35 if (!codec) { 33 if (!codec) {
36 JZSDK_LOG_ERROR("Codec not found\n"); 34 JZSDK_LOG_ERROR("Codec not found\n");
37 } 35 }
38 36
39 - //获得裸流的解析器  
40 parser = av_parser_init(codec->id); 37 parser = av_parser_init(codec->id);
41 if (!parser) { 38 if (!parser) {
42 JZSDK_LOG_ERROR("Parser not found\n"); 39 JZSDK_LOG_ERROR("Parser not found\n");
43 } 40 }
44 41
45 - //分配解码上下文  
46 cdc_ctx = avcodec_alloc_context3(codec); 42 cdc_ctx = avcodec_alloc_context3(codec);
47 if (!cdc_ctx) { 43 if (!cdc_ctx) {
48 JZSDK_LOG_ERROR("Could not allocate audio codec context\n"); 44 JZSDK_LOG_ERROR("Could not allocate audio codec context\n");
49 } 45 }
50 46
51 - //将解码器和解码上下文绑定 47 + /* open it */
52 if (avcodec_open2(cdc_ctx, codec, NULL) < 0) 48 if (avcodec_open2(cdc_ctx, codec, NULL) < 0)
53 { 49 {
54 JZSDK_LOG_ERROR("Could not open codec\n"); 50 JZSDK_LOG_ERROR("Could not open codec\n");
55 } 51 }
56 52
57 - JZSDK_LOG_INFO("file stream init complete");  
58 -  
59 - return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS; 53 + JZSDK_LOG_INFO("File_Stream_deal_Init success");
60 } 54 }
61 55
62 //输入mp3的实时数据，以及本次数据的长度 56 //输入mp3的实时数据，以及本次数据的长度
63 T_JZsdkReturnCode mp3_Stream_Interface_Mp3Data(struct AudioDealInfo *AD_Info, unsigned int in_sampleRate, unsigned char *data, int dataSize) 57 T_JZsdkReturnCode mp3_Stream_Interface_Mp3Data(struct AudioDealInfo *AD_Info, unsigned int in_sampleRate, unsigned char *data, int dataSize)
64 { 58 {
65 - //JZSDK_LOG_DEBUG("mp3 stream输入 %d 字节数据", dataSize); 59 + //JZSDK_LOG_DEBUG("mp3_Stream_Interface_Mp3Data");
66 60
67 - //重置重采样器  
68 - FF_Resample_Reset(AD_Info, in_sampleRate, (AVChannelLayout)AV_CHANNEL_LAYOUT_MONO, AV_SAMPLE_FMT_S16);  
69 -  
70 - //检查滤波器  
71 - FF_Filter_Init(AD_Info, 0x01);  
72 -  
73 - int ret = 0;  
74 - unsigned char *databufPtr = data;  
75 - int databufSize = dataSize; 61 + T_JZsdkReturnCode ret = JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
76 62
77 //将数据输入到 63 //将数据输入到
78 - while(databufSize > 0) 64 + while(dataSize > 0 && (AD_Info->AudioDeal_ResampleAndFilter_Execute_Flag == JZ_FLAGCODE_ON))
79 { 65 {
  66 + //printf("开始解码\n");
  67 +
80 //如果解码器不存在，初始化解码器 68 //如果解码器不存在，初始化解码器
81 if (!decoded_frame) 69 if (!decoded_frame)
82 { 70 {
@@ -87,31 +75,47 @@ T_JZsdkReturnCode mp3_Stream_Interface_Mp3Data(struct AudioDealInfo *AD_Info, un @@ -87,31 +75,47 @@ T_JZsdkReturnCode mp3_Stream_Interface_Mp3Data(struct AudioDealInfo *AD_Info, un
87 } 75 }
88 } 76 }
89 77
  78 + //printf("alloc后\n");
  79 +
90 //检查参数，并将正确的数据输入到pkt中 80 //检查参数，并将正确的数据输入到pkt中
91 //parser 解析器 81 //parser 解析器
92 //cdc_ctx 上下文 82 //cdc_ctx 上下文
93 //pkt输出的数据指针 83 //pkt输出的数据指针
94 //data datasize 输入的数据指针 84 //data datasize 输入的数据指针
95 //pts、dts、pos：时间戳和位置信息，一般可以设置为AV_NOPTS_VALUE和0。 85 //pts、dts、pos：时间戳和位置信息，一般可以设置为AV_NOPTS_VALUE和0。
96 - ret = av_parser_parse2(parser, cdc_ctx, &pkt->data, &pkt->size, databufPtr, databufSize, AV_NOPTS_VALUE, AV_NOPTS_VALUE, 0); 86 + int ret = av_parser_parse2(parser, cdc_ctx, &pkt->data, &pkt->size, data, dataSize, AV_NOPTS_VALUE, AV_NOPTS_VALUE, 0);
97 if (ret < 0) { 87 if (ret < 0) {
98 - printf("Error while parsing\n"); 88 + JZSDK_LOG_ERROR("Error while parsing\n");
99 return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE; 89 return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
100 } 90 }
101 91
  92 + //printf("av_parser_parse2\n");
  93 +
  94 + //重置重采样器
  95 + FF_Resample_Reset(AD_Info, in_sampleRate, (AVChannelLayout)AV_CHANNEL_LAYOUT_MONO, AV_SAMPLE_FMT_S16);
  96 +
  97 + //printf("FF_Resample_Reset\n");
  98 +
  99 + //检查滤波器
  100 + FF_Filter_Init(AD_Info, 0x01);
  101 +
  102 + //printf("FF_Filter_Init %d \n", pkt->size );
  103 +
102 //数据指针 往后一个解析长度 104 //数据指针 往后一个解析长度
103 //长度指针 减少一个被解析数据的长度 105 //长度指针 减少一个被解析数据的长度
104 - databufPtr += ret;  
105 - databufSize -= ret; 106 + data += ret;
  107 + dataSize -= ret;
106 108
107 //如果输出有长度 解码输出的数据 109 //如果输出有长度 解码输出的数据
108 if (pkt->size > 0) 110 if (pkt->size > 0)
109 { 111 {
110 - Stream_Player_decode(AD_Info, cdc_ctx, pkt, decoded_frame); 112 + ret = Stream_Player_decode(AD_Info, cdc_ctx, pkt, decoded_frame);
  113 + if(ret == JZ_ERROR_SYSTEM_MODULE_CODE_HARDLY_FAILURE)
  114 + {
  115 + return JZ_ERROR_SYSTEM_MODULE_CODE_HARDLY_FAILURE;
  116 + }
111 } 117 }
112 } 118 }
113 -  
114 - return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;  
115 } 119 }
116 120
117 121
@@ -121,17 +125,14 @@ T_JZsdkReturnCode Stream_Player_decode(struct AudioDealInfo *AD_Info, AVCodecCon @@ -121,17 +125,14 @@ T_JZsdkReturnCode Stream_Player_decode(struct AudioDealInfo *AD_Info, AVCodecCon
121 { 125 {
122 int ret; 126 int ret;
123 127
  128 + //JZSDK_LOG_DEBUG("Stream_Player_decode");
  129 +
124 //发送数据包给解码器解码，已将数据解码为pcm原始数据 130 //发送数据包给解码器解码，已将数据解码为pcm原始数据
125 ret = avcodec_send_packet(dec_ctx, pkt); 131 ret = avcodec_send_packet(dec_ctx, pkt);
126 - if (ret == AVERROR(EAGAIN))  
127 - {  
128 - char errbuf[128];  
129 - av_strerror(ret, errbuf, sizeof(errbuf));  
130 - JZSDK_LOG_ERROR("Error while sending a packet to the decoder %s",errbuf);  
131 - }  
132 - else if (ret < 0) 132 + if (ret < 0)
133 { 133 {
134 JZSDK_LOG_ERROR("Error submitting the packet to the decoder, ret=%d\n",ret); 134 JZSDK_LOG_ERROR("Error submitting the packet to the decoder, ret=%d\n",ret);
  135 + //return JZ_ERROR_SYSTEM_MODULE_CODE_HARDLY_FAILURE;
135 return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE; 136 return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
136 } 137 }
137 138
@@ -139,27 +140,36 @@ T_JZsdkReturnCode Stream_Player_decode(struct AudioDealInfo *AD_Info, AVCodecCon @@ -139,27 +140,36 @@ T_JZsdkReturnCode Stream_Player_decode(struct AudioDealInfo *AD_Info, AVCodecCon
139 AVFrame *eq_frame = av_frame_alloc(); 140 AVFrame *eq_frame = av_frame_alloc();
140 AVFrame *temp_frame = av_frame_alloc(); 141 AVFrame *temp_frame = av_frame_alloc();
141 142
  143 + //JZSDK_LOG_DEBUG("alloc");
  144 +
142 /* read all the output frames (in general there may be any number of them */ 145 /* read all the output frames (in general there may be any number of them */
143 //读取输出的帧 146 //读取输出的帧
144 - while ( (ret >= 0) && AD_Info->AudioDeal_ResampleAndFilter_Execute_Flag == JZ_FLAGCODE_ON) 147 + while ( (ret >= 0) && (AD_Info->AudioDeal_ResampleAndFilter_Execute_Flag == JZ_FLAGCODE_ON) )
145 { 148 {
146 //从解码器中读取解码后的音频帧数据 149 //从解码器中读取解码后的音频帧数据
147 ret = avcodec_receive_frame(dec_ctx, frame); 150 ret = avcodec_receive_frame(dec_ctx, frame);
148 //输出帧不可用 、 输出帧 已用完 151 //输出帧不可用 、 输出帧 已用完
149 if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) 152 if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
150 { 153 {
151 - break; 154 + continue;;
152 } 155 }
153 else if (ret < 0) 156 else if (ret < 0)
154 { 157 {
155 JZSDK_LOG_ERROR("Error during decoding\n"); 158 JZSDK_LOG_ERROR("Error during decoding\n");
  159 +
  160 + //释放掉输出的变量
  161 + av_frame_free(&eq_frame);
  162 + av_frame_free(&temp_frame);
  163 +
  164 + //JZSDK_LOG_DEBUG("提前释放后\n");
  165 +
156 return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE; 166 return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
157 } 167 }
158 168
159 - //printf("输出了:%d的数据\n",frame->nb_samples);  
160 -  
161 int out_nb_samples = 0; 169 int out_nb_samples = 0;
162 170
  171 + //JZSDK_LOG_DEBUG("播放前");
  172 +
163 //重采样解码后的数据 173 //重采样解码后的数据
164 void* resampledData = FF_Resample_Send_And_Get_ResampleData(AD_Info, frame->data, frame->nb_samples, &out_nb_samples); 174 void* resampledData = FF_Resample_Send_And_Get_ResampleData(AD_Info, frame->data, frame->nb_samples, &out_nb_samples);
165 175
@@ -181,8 +191,6 @@ T_JZsdkReturnCode Stream_Player_decode(struct AudioDealInfo *AD_Info, AVCodecCon @@ -181,8 +191,6 @@ T_JZsdkReturnCode Stream_Player_decode(struct AudioDealInfo *AD_Info, AVCodecCon
181 break; 191 break;
182 } 192 }
183 193
184 - //printf("pcm播放 %d 数据\n",eq_frame->nb_samples);  
185 -  
186 //播放改滤波后的帧 194 //播放改滤波后的帧
187 Pcm_AlsaPlay(AD_Info, (unsigned char*)eq_frame->data[0], eq_frame->nb_samples); 195 Pcm_AlsaPlay(AD_Info, (unsigned char*)eq_frame->data[0], eq_frame->nb_samples);
188 196
@@ -201,17 +209,18 @@ T_JZsdkReturnCode Stream_Player_decode(struct AudioDealInfo *AD_Info, AVCodecCon @@ -201,17 +209,18 @@ T_JZsdkReturnCode Stream_Player_decode(struct AudioDealInfo *AD_Info, AVCodecCon
201 FF_Resample_freeReasmpleData(resampledData); 209 FF_Resample_freeReasmpleData(resampledData);
202 } 210 }
203 211
  212 + //JZSDK_LOG_DEBUG("怀疑释放前\n");
  213 +
204 //释放掉输出的变量 214 //释放掉输出的变量
205 av_frame_unref(temp_frame); 215 av_frame_unref(temp_frame);
206 av_frame_unref(eq_frame); 216 av_frame_unref(eq_frame);
207 217
  218 + //JZSDK_LOG_DEBUG("怀疑释放后\n");
208 } 219 }
209 220
210 -T_JZsdkReturnCode Stream_Player_Stop(struct AudioDealInfo *AD_Info) 221 +T_JZsdkReturnCode mp3_Stream_Interface_Mp3Data_Stop(struct AudioDealInfo *AD_Info)
211 { 222 {
212 - pkt->data = NULL;  
213 - pkt->size = 0;  
214 - Stream_Player_decode(AD_Info, cdc_ctx, pkt, decoded_frame);  
215 -  
216 - return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS; 223 + // pkt->data = NULL;
  224 + // pkt->size = 0;
  225 + // Stream_Player_decode(AD_Info, cdc_ctx, pkt, decoded_frame);
217 } 226 }
@@ -821,6 +821,7 @@ T_JZsdkReturnCode Gimbal_Flush_Pitch() @@ -821,6 +821,7 @@ T_JZsdkReturnCode Gimbal_Flush_Pitch()
821 static T_JZsdkReturnCode Gimbal_Init_Gimbal_Init_TransparentControl() 821 static T_JZsdkReturnCode Gimbal_Init_Gimbal_Init_TransparentControl()
822 { 822 {
823 // 823 //
  824 + g_Gimbal_Mode = JZ_MODULE_CONTROL_WAY_TRANSPARENT;
824 825
825 826
826 return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS; 827 return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
@@ -835,6 +836,9 @@ static T_JZsdkReturnCode Gimbal_Init_Gimbal_Init_TransparentControl() @@ -835,6 +836,9 @@ static T_JZsdkReturnCode Gimbal_Init_Gimbal_Init_TransparentControl()
835 * **************************/ 836 * **************************/
836 static T_JZsdkReturnCode Gimbal_Init_IndependentControl() 837 static T_JZsdkReturnCode Gimbal_Init_IndependentControl()
837 { 838 {
  839 + g_Gimbal_Mode = JZ_MODULE_CONTROL_WAY_INDEPENDENT;
  840 +
  841 +
838 //舵机初始化 842 //舵机初始化
839 Gimal_MotorInit(); 843 Gimal_MotorInit();
840 844
@@ -11,6 +11,7 @@ @@ -11,6 +11,7 @@
11 11
12 #include "Hal_Send/HalSend.h" 12 #include "Hal_Send/HalSend.h"
13 #include "JZsdk_uart/JZsdk_Uart.h" 13 #include "JZsdk_uart/JZsdk_Uart.h"
  14 +#include "Ircut/H3_ircut/H3_ircut.h"
14 15
15 #ifdef WIRINGPI_STATUS_ON 16 #ifdef WIRINGPI_STATUS_ON
16 #include <wiringPi.h> 17 #include <wiringPi.h>
@@ -145,6 +145,7 @@ T_JZsdkReturnCode H3_ircut_init() @@ -145,6 +145,7 @@ T_JZsdkReturnCode H3_ircut_init()
145 if (DEVICE_VERSION == JZ_H10) 145 if (DEVICE_VERSION == JZ_H10)
146 { 146 {
147 pinMode(MOTOR_IRCUT_PIN,PWM_OUTPUT);//设置输出模式 147 pinMode(MOTOR_IRCUT_PIN,PWM_OUTPUT);//设置输出模式
  148 + JZSDK_LOG_INFO("H3 gimbal Init Complete");
148 } 149 }
149 150
150 JZSDK_LOG_INFO("H3 Init Complete"); 151 JZSDK_LOG_INFO("H3 Init Complete");
@@ -25,6 +25,9 @@ typedef struct IRC_param @@ -25,6 +25,9 @@ typedef struct IRC_param
25 { 25 {
26 int DealWay; //0为JZSDK自带的红外处理，1为KT库的红外处理 26 int DealWay; //0为JZSDK自带的红外处理，1为KT库的红外处理
27 27
  28 + int Filp_V; //垂直翻转
  29 + int Filp_H; //水平翻转
  30 +
28 int ImgDataBits; //图像位数 31 int ImgDataBits; //图像位数
29 int ExpectedMax; //最大灰度值 32 int ExpectedMax; //最大灰度值
30 int Gain; //对比度，这里设为 11 33 int Gain; //对比度，这里设为 11
@@ -89,11 +92,11 @@ typedef struct IRC_param @@ -89,11 +92,11 @@ typedef struct IRC_param
89 U16_t *Factory_LowT_Mark_Data; //出厂的低温标定帧灰度 92 U16_t *Factory_LowT_Mark_Data; //出厂的低温标定帧灰度
90 unsigned int Factory_LowT_Mark_Data_flag; //出厂的高温标定帧灰度标志位 93 unsigned int Factory_LowT_Mark_Data_flag; //出厂的高温标定帧灰度标志位
91 94
92 - U16_t *HighT_NineFrameAdd; //高温温度判定时的9帧综合数组 95 + int *HighT_NineFrameAdd; //高温温度判定时的9帧综合数组
93 U16_t *HighT_NineFrame_Avg; //高温温度判定时的9帧综合数组平均值 96 U16_t *HighT_NineFrame_Avg; //高温温度判定时的9帧综合数组平均值
94 unsigned int HighT_flag; //高温判定标志 0~9 0关闭，1~9 为计数 97 unsigned int HighT_flag; //高温判定标志 0~9 0关闭，1~9 为计数
95 98
96 - U16_t *LowT_NineFrameAdd; //低温温度判断时的9帧综合数组 99 + int *LowT_NineFrameAdd; //低温温度判断时的9帧综合数组
97 U16_t *LowT_NineFrame_Avg; //低温温度判定时的9帧综合数组平均值 100 U16_t *LowT_NineFrame_Avg; //低温温度判定时的9帧综合数组平均值
98 unsigned int LowT_flag; //低温判定标志 0~9 0关闭，1~9 为计数 101 unsigned int LowT_flag; //低温判定标志 0~9 0关闭，1~9 为计数
99 102
@@ -50,7 +50,10 @@ T_JZsdkReturnCode IRC_LowT_CycleCalibration(U16_t *ImageData,struct IRC_param *d @@ -50,7 +50,10 @@ T_JZsdkReturnCode IRC_LowT_CycleCalibration(U16_t *ImageData,struct IRC_param *d
50 { 50 {
51 JZSDK_LOG_DEBUG("开始低温标定"); 51 JZSDK_LOG_DEBUG("开始低温标定");
52 memset(dealInfo->LowT_NineFrameAdd, 0, dealInfo->PixelNum); 52 memset(dealInfo->LowT_NineFrameAdd, 0, dealInfo->PixelNum);
53 - memcpy(dealInfo->LowT_NineFrameAdd, ImageData, dealInfo->PixelNum * sizeof(U16_t)); 53 + for (int i = 0; i < dealInfo->PixelNum; i++)
  54 + {
  55 + dealInfo->LowT_NineFrameAdd[i] += ImageData[i];
  56 + }
54 dealInfo->LowT_flag++; 57 dealInfo->LowT_flag++;
55 } 58 }
56 else if (dealInfo->LowT_flag == JZ_FLAGCODE_OFF) 59 else if (dealInfo->LowT_flag == JZ_FLAGCODE_OFF)
@@ -61,7 +64,7 @@ T_JZsdkReturnCode IRC_LowT_CycleCalibration(U16_t *ImageData,struct IRC_param *d @@ -61,7 +64,7 @@ T_JZsdkReturnCode IRC_LowT_CycleCalibration(U16_t *ImageData,struct IRC_param *d
61 else 64 else
62 { 65 {
63 //否则累加存储数组 66 //否则累加存储数组
64 - for (int i = 0; i < (dealInfo->Width * dealInfo->Height); i++) 67 + for (int i = 0; i < dealInfo->PixelNum; i++)
65 { 68 {
66 dealInfo->LowT_NineFrameAdd[i] += ImageData[i]; 69 dealInfo->LowT_NineFrameAdd[i] += ImageData[i];
67 } 70 }
@@ -75,7 +78,7 @@ T_JZsdkReturnCode IRC_LowT_CycleCalibration(U16_t *ImageData,struct IRC_param *d @@ -75,7 +78,7 @@ T_JZsdkReturnCode IRC_LowT_CycleCalibration(U16_t *ImageData,struct IRC_param *d
75 { 78 {
76 for (int i = 0; i < (dealInfo->Width * dealInfo->Height); i++) 79 for (int i = 0; i < (dealInfo->Width * dealInfo->Height); i++)
77 { 80 {
78 - dealInfo->LowT_NineFrame_Avg[i] = dealInfo->LowT_NineFrameAdd[i] / 9; 81 + dealInfo->LowT_NineFrame_Avg[i] = (int)(dealInfo->LowT_NineFrameAdd[i] / 9);
79 } 82 }
80 83
81 dealInfo->LowT_flag = JZ_FLAGCODE_OFF; //将标志位归位 84 dealInfo->LowT_flag = JZ_FLAGCODE_OFF; //将标志位归位
@@ -104,7 +107,11 @@ T_JZsdkReturnCode IRC_HighT_CycleCalibration(U16_t *ImageData, struct IRC_param @@ -104,7 +107,11 @@ T_JZsdkReturnCode IRC_HighT_CycleCalibration(U16_t *ImageData, struct IRC_param
104 { 107 {
105 JZSDK_LOG_DEBUG("开始高温标定"); 108 JZSDK_LOG_DEBUG("开始高温标定");
106 memset(dealInfo->HighT_NineFrameAdd, 0, dealInfo->PixelNum); 109 memset(dealInfo->HighT_NineFrameAdd, 0, dealInfo->PixelNum);
107 - memcpy(dealInfo->HighT_NineFrameAdd, ImageData, dealInfo->PixelNum * sizeof(U16_t)); 110 + for (int i = 0; i < dealInfo->PixelNum; i++)
  111 + {
  112 + dealInfo->HighT_NineFrameAdd[i] += ImageData[i];
  113 + }
  114 +
108 dealInfo->HighT_flag++; 115 dealInfo->HighT_flag++;
109 } 116 }
110 else if (dealInfo->HighT_flag == JZ_FLAGCODE_OFF) 117 else if (dealInfo->HighT_flag == JZ_FLAGCODE_OFF)
@@ -115,7 +122,7 @@ T_JZsdkReturnCode IRC_HighT_CycleCalibration(U16_t *ImageData, struct IRC_param @@ -115,7 +122,7 @@ T_JZsdkReturnCode IRC_HighT_CycleCalibration(U16_t *ImageData, struct IRC_param
115 else 122 else
116 { 123 {
117 //否则累加存储数组 124 //否则累加存储数组
118 - for (int i = 0; i < (dealInfo->Width * dealInfo->Height); i++) 125 + for (int i = 0; i < dealInfo->PixelNum; i++)
119 { 126 {
120 dealInfo->HighT_NineFrameAdd[i] += ImageData[i]; 127 dealInfo->HighT_NineFrameAdd[i] += ImageData[i];
121 } 128 }
@@ -128,7 +135,7 @@ T_JZsdkReturnCode IRC_HighT_CycleCalibration(U16_t *ImageData, struct IRC_param @@ -128,7 +135,7 @@ T_JZsdkReturnCode IRC_HighT_CycleCalibration(U16_t *ImageData, struct IRC_param
128 { 135 {
129 for (int i = 0; i < (dealInfo->Width * dealInfo->Height); i++) 136 for (int i = 0; i < (dealInfo->Width * dealInfo->Height); i++)
130 { 137 {
131 - dealInfo->HighT_NineFrame_Avg[i] = dealInfo->HighT_NineFrameAdd[i] / 9; 138 + dealInfo->HighT_NineFrame_Avg[i] = (U16_t)(dealInfo->HighT_NineFrameAdd[i] / 9);
132 } 139 }
133 140
134 dealInfo->HighT_flag = JZ_FLAGCODE_OFF; //将标志位归位 141 dealInfo->HighT_flag = JZ_FLAGCODE_OFF; //将标志位归位
@@ -886,7 +893,8 @@ T_JZsdkReturnCode IRC_LocalFrame_DataWrite(int flag,struct IRC_param *dealInfo, @@ -886,7 +893,8 @@ T_JZsdkReturnCode IRC_LocalFrame_DataWrite(int flag,struct IRC_param *dealInfo,
886 893
887 //写入数据 894 //写入数据
888 for (int i = 0; i < image_size; i++) { 895 for (int i = 0; i < image_size; i++) {
889 - fprintf(fp, "%d ", image[i]); 896 + //fprintf(fp, "%d ", image[i]);
  897 + fprintf(fp, "%u ", (unsigned int)image[i]);
890 } 898 }
891 899
892 fclose(fp); // 关闭文件 900 fclose(fp); // 关闭文件
@@ -21,6 +21,8 @@ int g_temp_GasValueMin = 30; @@ -21,6 +21,8 @@ int g_temp_GasValueMin = 30;
21 21
22 struct IRC_param *g_IRC_Param = NULL; 22 struct IRC_param *g_IRC_Param = NULL;
23 static T_JZsdkReturnCode IRC_param_Init(struct IRC_param **index, int height, int width, int frameRate); 23 static T_JZsdkReturnCode IRC_param_Init(struct IRC_param **index, int height, int width, int frameRate);
  24 +static int lastSPCMode = -1; //0低温数据 1手动打档 2自动打档
  25 +static int lastTPCMode = -1;
24 26
25 static FILE *temp_fp = NULL; 27 static FILE *temp_fp = NULL;
26 28
@@ -107,6 +109,15 @@ static T_JZsdkReturnCode IRC_data_PreliminaryDeal(U16_t *rawData ,unsigned int * @@ -107,6 +109,15 @@ static T_JZsdkReturnCode IRC_data_PreliminaryDeal(U16_t *rawData ,unsigned int *
107 JZsdk_CutBadPixel_U16(rawData, dealInfo->Width, dealInfo->Height, dealInfo->BadPixel, dealInfo->BadPixelNum,dealInfo->BadPixelExtern, 1); 109 JZsdk_CutBadPixel_U16(rawData, dealInfo->Width, dealInfo->Height, dealInfo->BadPixel, dealInfo->BadPixelNum,dealInfo->BadPixelExtern, 1);
108 } 110 }
109 111
  112 + // //盲点过后进行数据复查
  113 + // for (int i = 0; i < *rawSize; i++)
  114 + // {
  115 + // if (rawData[i] > dealInfo->ExpectedMax)
  116 + // {
  117 + // rawData[i] = dealInfo->ExpectedMax;
  118 + // }
  119 + // }
  120 +
110 /*************************************两点纠正部分******************************************************************/ 121 /*************************************两点纠正部分******************************************************************/
111 122
112 //判断两点的数据模式是否有改变 123 //判断两点的数据模式是否有改变
@@ -345,6 +356,35 @@ static T_JZsdkReturnCode IRC_data_PreliminaryDeal(U16_t *rawData ,unsigned int * @@ -345,6 +356,35 @@ static T_JZsdkReturnCode IRC_data_PreliminaryDeal(U16_t *rawData ,unsigned int *
345 dealInfo->FirstSPC_flag = JZ_FLAGCODE_ON; 356 dealInfo->FirstSPC_flag = JZ_FLAGCODE_ON;
346 } 357 }
347 358
  359 + //判断单点下石佛切换过单点模式（切换低温数据 或 手动打挡），如果切换过，鲲腾要重新注入spc数据
  360 + if ( (dealInfo->SPC_mode == 0 && lastSPCMode != 0 ) || (dealInfo->SPC_mode == 1 && lastSPCMode != 1))
  361 + {
  362 +#ifdef KTIRC_LIB_STATUS_ON
  363 + if (dealInfo->SPC_mode == 0)
  364 + {
  365 + KtLib_writeMarkData(SPC_MARK_DATA, dealInfo->LowT_NineFrame_Avg ,dealInfo->PixelNum);
  366 + }
  367 +
  368 + if (dealInfo->SPC_mode == 1)
  369 + {
  370 + //此时spc数据应该是换过的
  371 + KtLib_writeMarkData(SPC_MARK_DATA, dealInfo->SPC_Mark_Data ,dealInfo->PixelNum);
  372 + }
  373 +#endif
  374 + }
  375 +
  376 + lastSPCMode = dealInfo->SPC_mode;
  377 +
  378 + //判断单点模式 选择了低温数据的情况下，是否切换过低温数据组
  379 + if (dealInfo->SPC_mode == 0)
  380 + {
  381 + if (lastTPCMode != dealInfo->TPC_mode)
  382 + {
  383 + KtLib_writeMarkData(SPC_MARK_DATA, dealInfo->LowT_NineFrame_Avg ,dealInfo->PixelNum);
  384 + lastTPCMode = dealInfo->TPC_mode;
  385 + }
  386 + }
  387 +
348 //如果处于自动打档模式 388 //如果处于自动打档模式
349 if (dealInfo->SPC_mode == 2) 389 if (dealInfo->SPC_mode == 2)
350 { 390 {
@@ -374,9 +414,11 @@ static T_JZsdkReturnCode IRC_data_PreliminaryDeal(U16_t *rawData ,unsigned int * @@ -374,9 +414,11 @@ static T_JZsdkReturnCode IRC_data_PreliminaryDeal(U16_t *rawData ,unsigned int *
374 IRC_LocalFrame_DataWrite(SPC_MARK_DATA, dealInfo, (U16_t *)dealInfo->SPC_Mark_Data, dealInfo->PixelNum); 414 IRC_LocalFrame_DataWrite(SPC_MARK_DATA, dealInfo, (U16_t *)dealInfo->SPC_Mark_Data, dealInfo->PixelNum);
375 415
376 //如果开启开启的昆腾库，则载入昆腾数据 416 //如果开启开启的昆腾库，则载入昆腾数据
377 - if (g_IRC_Param->DealWay == IRC_DEALMODE_KTLIB) 417 + if (g_IRC_Param->DealWay == IRC_DEALMODE_KTLIB && dealInfo->SPC_mode == 1)
378 { 418 {
  419 +#ifdef KTIRC_LIB_STATUS_ON
379 KtLib_writeMarkData(SPC_MARK_DATA ,dealInfo->SPC_Mark_Data, dealInfo->PixelNum); 420 KtLib_writeMarkData(SPC_MARK_DATA ,dealInfo->SPC_Mark_Data, dealInfo->PixelNum);
  421 +#endif
380 } 422 }
381 423
382 dealInfo->SPC_ResetFlag = JZ_FLAGCODE_OFF; 424 dealInfo->SPC_ResetFlag = JZ_FLAGCODE_OFF;
@@ -417,14 +459,8 @@ unsigned int Get_2DImage_PointToArray(int x, int y, int width, int height) @@ -417,14 +459,8 @@ unsigned int Get_2DImage_PointToArray(int x, int y, int width, int height)
417 static T_JZsdkReturnCode IRC_Postdeal(unsigned char *rgb_data, struct IRC_param *dealInfo) 459 static T_JZsdkReturnCode IRC_Postdeal(unsigned char *rgb_data, struct IRC_param *dealInfo)
418 { 460 {
419 //将rgb图形镜像 461 //将rgb图形镜像
420 - int MirrorImageFlag = JZ_FLAGCODE_ON;  
421 - if (dealInfo->DealWay == IRC_DEALMODE_KTLIB)  
422 - {  
423 - MirrorImageFlag = JZ_FLAGCODE_OFF;  
424 - }  
425 -  
426 -  
427 - if (MirrorImageFlag == JZ_FLAGCODE_ON) 462 + //水平镜像
  463 + if (dealInfo->Filp_H == JZ_FLAGCODE_ON)
428 { 464 {
429 int x, y = 0; 465 int x, y = 0;
430 466
@@ -457,6 +493,32 @@ static T_JZsdkReturnCode IRC_Postdeal(unsigned char *rgb_data, struct IRC_param @@ -457,6 +493,32 @@ static T_JZsdkReturnCode IRC_Postdeal(unsigned char *rgb_data, struct IRC_param
457 free(temp_row); // 释放临时缓冲区 493 free(temp_row); // 释放临时缓冲区
458 } 494 }
459 495
  496 + //垂直镜像
  497 + if (dealInfo->Filp_V == JZ_FLAGCODE_ON) // 假设Filp_V是控制垂直翻转的标志
  498 + {
  499 + int x, y = 0;
  500 + int bytes_per_row = dealInfo->Width * 3; // 每行的字节数，假设图像是RGB格式
  501 + unsigned char *temp_image = (unsigned char *)malloc(dealInfo->Height * bytes_per_row); // 临时缓冲区，用于存储整个图像的像素数据
  502 +
  503 + if (temp_image == NULL) {
  504 + // 内存分配失败处理
  505 + return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
  506 + }
  507 +
  508 + // 复制整个图像到临时缓冲区
  509 + memcpy(temp_image, rgb_data, dealInfo->Height * bytes_per_row);
  510 +
  511 + // 遍历图像的每一行
  512 + for (y = 0; y < dealInfo->Height; y++) {
  513 + // 从临时缓冲区中复制对应行的数据回原图像，但是是从底部向上（即反向）复制
  514 + memcpy(rgb_data + (dealInfo->Height - 1 - y) * bytes_per_row,
  515 + temp_image + y * bytes_per_row,
  516 + bytes_per_row);
  517 + }
  518 +
  519 + free(temp_image); // 释放临时缓冲区
  520 + }
  521 +
460 //修复外圈图像 522 //修复外圈图像
461 if (dealInfo->RingRepair == JZ_FLAGCODE_ON) 523 if (dealInfo->RingRepair == JZ_FLAGCODE_ON)
462 { 524 {
@@ -618,12 +680,12 @@ T_JZsdkReturnCode IRC_FrameDeal(U16_t *rawData ,unsigned int dataSize, unsigned @@ -618,12 +680,12 @@ T_JZsdkReturnCode IRC_FrameDeal(U16_t *rawData ,unsigned int dataSize, unsigned
618 680
619 //JZSDK_LOG_DEBUG("数据预处理完成"); 681 //JZSDK_LOG_DEBUG("数据预处理完成");
620 682
621 - if (temp_fp != NULL)  
622 - {  
623 - fwrite(rawData, sizeof(U16_t), dataSize, temp_fp); 683 + // if (temp_fp != NULL)
  684 + // {
  685 + // fwrite(rawData, sizeof(U16_t), dataSize, temp_fp);
624 686
625 - fflush(temp_fp);  
626 - } 687 + // fflush(temp_fp);
  688 + // }
627 689
628 690
629 //2、数据前处理，将原始数据和16位数据 合成为rgb数据 691 //2、数据前处理，将原始数据和16位数据 合成为rgb数据
@@ -1194,6 +1256,24 @@ static T_JZsdkReturnCode IRC_param_Init(struct IRC_param **index, int height, in @@ -1194,6 +1256,24 @@ static T_JZsdkReturnCode IRC_param_Init(struct IRC_param **index, int height, in
1194 //IrcDealCfg->DealWay = IRC_DEALMODE_JZSDK; 1256 //IrcDealCfg->DealWay = IRC_DEALMODE_JZSDK;
1195 IrcDealCfg->DealWay = IRC_DEALMODE_KTLIB; 1257 IrcDealCfg->DealWay = IRC_DEALMODE_KTLIB;
1196 1258
  1259 + //我们自己库要水平翻转
  1260 + if (IrcDealCfg->DealWay == IRC_DEALMODE_JZSDK)
  1261 + {
  1262 + IrcDealCfg->Filp_H = JZ_FLAGCODE_ON;
  1263 + }
  1264 + //鲲腾的库要垂直翻转
  1265 + else if (IrcDealCfg->DealWay == IRC_DEALMODE_KTLIB)
  1266 + {
  1267 + IrcDealCfg->Filp_V = JZ_FLAGCODE_ON;
  1268 + }
  1269 + //否则都不翻转
  1270 + else
  1271 + {
  1272 + IrcDealCfg->Filp_H = JZ_FLAGCODE_OFF;
  1273 + IrcDealCfg->Filp_V = JZ_FLAGCODE_OFF;
  1274 + }
  1275 +
  1276 +
1197 IrcDealCfg->ImgDataBits = 14; //图像为14位图像 1277 IrcDealCfg->ImgDataBits = 14; //图像为14位图像
1198 IrcDealCfg->Height = height; 1278 IrcDealCfg->Height = height;
1199 IrcDealCfg->Width = width; 1279 IrcDealCfg->Width = width;
@@ -1238,13 +1318,13 @@ static T_JZsdkReturnCode IRC_param_Init(struct IRC_param **index, int height, in @@ -1238,13 +1318,13 @@ static T_JZsdkReturnCode IRC_param_Init(struct IRC_param **index, int height, in
1238 JZSDK_LOG_ERROR("TPC_Gain注册失败"); 1318 JZSDK_LOG_ERROR("TPC_Gain注册失败");
1239 } 1319 }
1240 1320
1241 - IrcDealCfg->HighT_NineFrameAdd = (U16_t *)malloc(IrcDealCfg->PixelNum * sizeof(U16_t)); 1321 + IrcDealCfg->HighT_NineFrameAdd = (int *)malloc(IrcDealCfg->PixelNum * sizeof(int));
1242 if (IrcDealCfg->HighT_NineFrameAdd == NULL) 1322 if (IrcDealCfg->HighT_NineFrameAdd == NULL)
1243 { 1323 {
1244 JZSDK_LOG_ERROR("HighT_NineFrameAdd注册失败"); 1324 JZSDK_LOG_ERROR("HighT_NineFrameAdd注册失败");
1245 } 1325 }
1246 1326
1247 - IrcDealCfg->LowT_NineFrameAdd = (U16_t *)malloc(IrcDealCfg->PixelNum * sizeof(U16_t)); 1327 + IrcDealCfg->LowT_NineFrameAdd = (int *)malloc(IrcDealCfg->PixelNum * sizeof(int));
1248 if (IrcDealCfg->LowT_NineFrameAdd == NULL) 1328 if (IrcDealCfg->LowT_NineFrameAdd == NULL)
1249 { 1329 {
1250 JZSDK_LOG_ERROR("LowT_NineFrameAdd注册失败"); 1330 JZSDK_LOG_ERROR("LowT_NineFrameAdd注册失败");
@@ -40,7 +40,7 @@ T_JZsdkReturnCode KtLib_Init(struct IRC_param *dealInfo) @@ -40,7 +40,7 @@ T_JZsdkReturnCode KtLib_Init(struct IRC_param *dealInfo)
40 /********************************************** 40 /**********************************************
41 * 41 *
42 * 42 *
43 - * 43 + * ktlib 写入标定的数据
44 * 44 *
45 * 45 *
46 * **********************************************/ 46 * **********************************************/
@@ -51,12 +51,19 @@ T_JZsdkReturnCode KtLib_writeMarkData(int type, U16_t* in ,int size) @@ -51,12 +51,19 @@ T_JZsdkReturnCode KtLib_writeMarkData(int type, U16_t* in ,int size)
51 // 加锁 51 // 加锁
52 std::lock_guard<std::mutex> lock(ktLibMutex); 52 std::lock_guard<std::mutex> lock(ktLibMutex);
53 53
  54 + int TempBuffer[size];
  55 +
  56 + for (int i = 0; i < size; i++)
  57 + {
  58 + TempBuffer[i] = in[i];
  59 + }
  60 +
54 #ifdef KTIRC_LIB_STATUS_ON 61 #ifdef KTIRC_LIB_STATUS_ON
55 switch (type) 62 switch (type)
56 { 63 {
57 //高温标记数据 64 //高温标记数据
58 case HIGH_TEMP_DATA: 65 case HIGH_TEMP_DATA:
59 - bool_ret = LoadMarkData((int *)in ,size,HIGH_MARK_DATA); 66 + bool_ret = LoadMarkData(TempBuffer ,size,HIGH_MARK_DATA);
60 if (bool_ret == false) 67 if (bool_ret == false)
61 { 68 {
62 JZSDK_LOG_ERROR("LoadMarkData HIGH_TEMP_DATA error"); 69 JZSDK_LOG_ERROR("LoadMarkData HIGH_TEMP_DATA error");
@@ -71,7 +78,7 @@ T_JZsdkReturnCode KtLib_writeMarkData(int type, U16_t* in ,int size) @@ -71,7 +78,7 @@ T_JZsdkReturnCode KtLib_writeMarkData(int type, U16_t* in ,int size)
71 78
72 //低温标记数据 79 //低温标记数据
73 case LOW_TEMP_DATA: 80 case LOW_TEMP_DATA:
74 - bool_ret = LoadMarkData((int *)in ,size,LOW_MARK_DATA); 81 + bool_ret = LoadMarkData(TempBuffer ,size,LOW_MARK_DATA);
75 if (bool_ret == false) 82 if (bool_ret == false)
76 { 83 {
77 JZSDK_LOG_ERROR("LoadMarkData LOW_TEMP_DATA error"); 84 JZSDK_LOG_ERROR("LoadMarkData LOW_TEMP_DATA error");
@@ -87,7 +94,7 @@ T_JZsdkReturnCode KtLib_writeMarkData(int type, U16_t* in ,int size) @@ -87,7 +94,7 @@ T_JZsdkReturnCode KtLib_writeMarkData(int type, U16_t* in ,int size)
87 94
88 //单点标记数据 95 //单点标记数据
89 case SPC_MARK_DATA: 96 case SPC_MARK_DATA:
90 - bool_ret = LoadMarkData((int *)in ,size, SINGLE_MARK_DATA); 97 + bool_ret = LoadMarkData(TempBuffer ,size, SINGLE_MARK_DATA);
91 if (bool_ret == false) 98 if (bool_ret == false)
92 { 99 {
93 JZSDK_LOG_ERROR("LoadMarkData SPC_MARK_DATA error"); 100 JZSDK_LOG_ERROR("LoadMarkData SPC_MARK_DATA error");
@@ -110,6 +117,9 @@ T_JZsdkReturnCode KtLib_writeMarkData(int type, U16_t* in ,int size) @@ -110,6 +117,9 @@ T_JZsdkReturnCode KtLib_writeMarkData(int type, U16_t* in ,int size)
110 } 117 }
111 118
112 static int lastCorrectMode = JZ_FLAGCODE_OFF; 119 static int lastCorrectMode = JZ_FLAGCODE_OFF;
  120 +static int DynamicGasesColorFlag = JZ_FLAGCODE_OFF;
  121 +
  122 +
113 123
114 T_JZsdkReturnCode KtLib_DataDeal(U16_t* U16_data, unsigned int U16_dataSize, 124 T_JZsdkReturnCode KtLib_DataDeal(U16_t* U16_data, unsigned int U16_dataSize,
115 U8_t **RGB_data, unsigned int *RGB_dataSize, 125 U8_t **RGB_data, unsigned int *RGB_dataSize,
@@ -184,17 +194,41 @@ T_JZsdkReturnCode KtLib_DataDeal(U16_t* U16_data, unsigned int U16_dataSize, @@ -184,17 +194,41 @@ T_JZsdkReturnCode KtLib_DataDeal(U16_t* U16_data, unsigned int U16_dataSize,
184 switch (dealInfo->OutputPixelColorMode) 194 switch (dealInfo->OutputPixelColorMode)
185 { 195 {
186 case 0: // 默认输出模式 196 case 0: // 默认输出模式
187 - case 2: // 气体色彩增强输出模式  
188 { 197 {
  198 + if (DynamicGasesColorFlag == JZ_FLAGCODE_ON)
  199 + {
  200 + CloseDynamicGasesColorEnhance();
  201 + DynamicGasesColorFlag = JZ_FLAGCODE_OFF;
  202 + }
  203 +
189 bool_ret = GetImageSynchronous(inputDataChar, inputDataSize, (char *)*RGB_data, dealInfo->PixelNum*3, (int *)RGB_dataSize); //同步处理数据 204 bool_ret = GetImageSynchronous(inputDataChar, inputDataSize, (char *)*RGB_data, dealInfo->PixelNum*3, (int *)RGB_dataSize); //同步处理数据
190 } 205 }
191 break; 206 break;
192 207
193 case 1: // 伪彩输出模式 208 case 1: // 伪彩输出模式
194 { 209 {
  210 + if (DynamicGasesColorFlag == JZ_FLAGCODE_ON)
  211 + {
  212 + CloseDynamicGasesColorEnhance();
  213 + DynamicGasesColorFlag = JZ_FLAGCODE_OFF;
  214 + }
  215 +
195 bool_ret = GetImageSynchronous(inputDataChar, inputDataSize, (char *)*RGB_data, dealInfo->PixelNum*3, (int *)RGB_dataSize); //同步处理数据 216 bool_ret = GetImageSynchronous(inputDataChar, inputDataSize, (char *)*RGB_data, dealInfo->PixelNum*3, (int *)RGB_dataSize); //同步处理数据
196 217
197 //将rgb888数据反转为灰度数据并进行颜色映射 218 //将rgb888数据反转为灰度数据并进行颜色映射
  219 + PseudoColor_GrayRgb2Rgb((*RGB_data), dealInfo->PixelNum);
  220 + }
  221 + break;
  222 +
  223 + case 2: // 气体色彩增强输出模式
  224 + {
  225 + if (DynamicGasesColorFlag == JZ_FLAGCODE_OFF)
  226 + {
  227 + OpenDynamicGasesColorEnhance();
  228 + DynamicGasesColorFlag = JZ_FLAGCODE_ON;
  229 + }
  230 +
  231 + bool_ret = GetImageSynchronous(inputDataChar, inputDataSize, (char *)*RGB_data, dealInfo->PixelNum*3, (int *)RGB_dataSize); //同步处理数据
198 } 232 }
199 break; 233 break;
200 234
@@ -265,7 +265,7 @@ T_JZsdkReturnCode JZsdk_CutBadPixel_U16(U16_t *image, int width, int height, uns @@ -265,7 +265,7 @@ T_JZsdkReturnCode JZsdk_CutBadPixel_U16(U16_t *image, int width, int height, uns
265 int Avged = (newPixel-image[tempLen])/8; 265 int Avged = (newPixel-image[tempLen])/8;
266 if ((fabs(image[tempLen] - Avged) < Buildextern)) 266 if ((fabs(image[tempLen] - Avged) < Buildextern))
267 { 267 {
268 - 268 + newPixel = 0;
269 for (int dy = -2; dy <= 2; dy++) 269 for (int dy = -2; dy <= 2; dy++)
270 { 270 {
271 for (int dx = -2; dx <= 2; dx++) 271 for (int dx = -2; dx <= 2; dx++)
@@ -294,12 +294,13 @@ T_JZsdkReturnCode JZsdk_CutBadPixel_U16(U16_t *image, int width, int height, uns @@ -294,12 +294,13 @@ T_JZsdkReturnCode JZsdk_CutBadPixel_U16(U16_t *image, int width, int height, uns
294 294
295 unsigned int newPixel = 0; 295 unsigned int newPixel = 0;
296 296
297 - //获取xy轴坐标 297 + //把盲点长度坐标转化为xy坐标
298 int tempLen = Blind[i]; 298 int tempLen = Blind[i];
299 PointY = tempLen/width; 299 PointY = tempLen/width;
300 PointX = tempLen%width; 300 PointX = tempLen%width;
301 - int index=0;  
302 - int Avged=0; 301 +
  302 + int index=0; //索引值
  303 + int Avged=0; //平均值
303 304
304 int tempPixel[25]; 305 int tempPixel[25];
305 306
@@ -307,16 +308,23 @@ T_JZsdkReturnCode JZsdk_CutBadPixel_U16(U16_t *image, int width, int height, uns @@ -307,16 +308,23 @@ T_JZsdkReturnCode JZsdk_CutBadPixel_U16(U16_t *image, int width, int height, uns
307 { 308 {
308 for (int dx = -2; dx <= 2; dx++) 309 for (int dx = -2; dx <= 2; dx++)
309 { 310 {
  311 +
310 // 计算5x5窗口中当前元素的索引 312 // 计算5x5窗口中当前元素的索引
311 int newY = PointY + dy; 313 int newY = PointY + dy;
312 int newX = PointX + dx; 314 int newX = PointX + dx;
313 tempPixel[index] = image[newY * width + newX]; 315 tempPixel[index] = image[newY * width + newX];
  316 +
  317 +
314 newPixel += tempPixel[index]; 318 newPixel += tempPixel[index];
315 index++; 319 index++;
316 } 320 }
317 } 321 }
318 322
319 - Avged = (newPixel-image[tempLen])/24; 323 + //移除中心点
  324 + newPixel -= image[tempLen];
  325 +
  326 + //计算周围24个点的平均值
  327 + Avged = newPixel/24;
320 328
321 int MaxAvgd = 0; 329 int MaxAvgd = 0;
322 int MinAvgd = 0; 330 int MinAvgd = 0;
@@ -112,6 +112,12 @@ T_JZsdkReturnCode PseudoColor_256Gray2Rgb_ResetColor(int value) @@ -112,6 +112,12 @@ T_JZsdkReturnCode PseudoColor_256Gray2Rgb_ResetColor(int value)
112 return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS; 112 return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
113 } 113 }
114 114
  115 +/*****************************
  116 + *
  117 + * 灰度图转伪彩rgb
  118 + *
  119 + *
  120 + * ***************************/
115 T_JZsdkReturnCode PseudoColor_Gray2Rgb(U8_t *in_str, U8_t **out_str, unsigned int *out_str_len, int PixelNum) 121 T_JZsdkReturnCode PseudoColor_Gray2Rgb(U8_t *in_str, U8_t **out_str, unsigned int *out_str_len, int PixelNum)
116 { 122 {
117 if (P_Color_FinishFlag != JZ_FLAGCODE_ON) 123 if (P_Color_FinishFlag != JZ_FLAGCODE_ON)
@@ -140,3 +146,27 @@ T_JZsdkReturnCode PseudoColor_Gray2Rgb(U8_t *in_str, U8_t **out_str, unsigned in @@ -140,3 +146,27 @@ T_JZsdkReturnCode PseudoColor_Gray2Rgb(U8_t *in_str, U8_t **out_str, unsigned in
140 146
141 return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS; 147 return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
142 } 148 }
  149 +
  150 +/*****************************
  151 + *
  152 + * 灰度rgb转伪彩rgb
  153 + *
  154 + *
  155 + * ***************************/
  156 +T_JZsdkReturnCode PseudoColor_GrayRgb2Rgb(U8_t *str, unsigned int PixelNum)
  157 +{
  158 + if (P_Color_FinishFlag != JZ_FLAGCODE_ON)
  159 + {
  160 + JZSDK_LOG_ERROR("伪彩配置文件未初始化");
  161 + return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
  162 + }
  163 +
  164 + for (int i = 0; i < PixelNum; i += 1)
  165 + {
  166 + str[3*i] = P_Color.R_color[str[3*i]];
  167 + str[3*i + 1] = P_Color.G_color[str[3*i + 1]];
  168 + str[3*i + 2] = P_Color.B_color[str[3*i + 2]];
  169 + }
  170 +
  171 + return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
  172 +}
@@ -41,6 +41,8 @@ typedef enum e_PseudoColor @@ -41,6 +41,8 @@ typedef enum e_PseudoColor
41 41
42 /* Exported functions --------------------------------------------------------*/ 42 /* Exported functions --------------------------------------------------------*/
43 T_JZsdkReturnCode PseudoColor_Gray2Rgb(U8_t *in_str, U8_t **out_str, unsigned int *out_str_len, int PixelNum); 43 T_JZsdkReturnCode PseudoColor_Gray2Rgb(U8_t *in_str, U8_t **out_str, unsigned int *out_str_len, int PixelNum);
  44 +T_JZsdkReturnCode PseudoColor_GrayRgb2Rgb(U8_t *str, unsigned int PixelNum);
  45 +
44 T_JZsdkReturnCode PseudoColor_256Gray2Rgb_ResetColor(int value); 46 T_JZsdkReturnCode PseudoColor_256Gray2Rgb_ResetColor(int value);
45 47
46 #ifdef __cplusplus 48 #ifdef __cplusplus
@@ -11,6 +11,9 @@ @@ -11,6 +11,9 @@
11 11
12 static int RealTimeMp2_StatusFlag = JZ_FLAGCODE_OFF; 12 static int RealTimeMp2_StatusFlag = JZ_FLAGCODE_OFF;
13 13
  14 +static int MP2_Loop_Flag = JZ_FLAGCODE_OFF;
  15 +static int MP2_Write_Flag = JZ_FLAGCODE_OFF;
  16 +
14 //解码播放部分 17 //解码播放部分
15 static unsigned char RealTimeMP2_PlayData_Loop[ (256 + 1) ][128];//解码缓存池 18 static unsigned char RealTimeMP2_PlayData_Loop[ (256 + 1) ][128];//解码缓存池
16 static int RealTimeMP2_PlayData_LoopHead = 0; //池数头 19 static int RealTimeMP2_PlayData_LoopHead = 0; //池数头
@@ -96,8 +99,6 @@ T_JZsdkReturnCode RealTimeMP2_start() @@ -96,8 +99,6 @@ T_JZsdkReturnCode RealTimeMP2_start()
96 return ret; 99 return ret;
97 } 100 }
98 101
99 - JZSDK_LOG_INFO("MP2实时喊话初始化成功");  
100 -  
101 return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS; 102 return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
102 } 103 }
103 104
@@ -123,7 +124,13 @@ T_JZsdkReturnCode RealTimeMP2_Close() @@ -123,7 +124,13 @@ T_JZsdkReturnCode RealTimeMP2_Close()
123 } 124 }
124 125
125 RealTimeMp2_StatusFlag = JZ_FLAGCODE_OFF; 126 RealTimeMp2_StatusFlag = JZ_FLAGCODE_OFF;
  127 +
  128 + //关闭loop线程
  129 + MP2_Loop_Flag = JZ_FLAGCODE_ON;
126 RealTimeMP2s_PlayData_LoopReadFlag = JZ_FLAGCODE_OFF; 130 RealTimeMP2s_PlayData_LoopReadFlag = JZ_FLAGCODE_OFF;
  131 +
  132 + //关闭write线程
  133 + //MP2_Write_Flag = JZ_FLAGCODE_ON;
127 RealTimeMP2_WriteFlag = JZ_FLAGCODE_OFF; 134 RealTimeMP2_WriteFlag = JZ_FLAGCODE_OFF;
128 135
129 Megaphone_MegDataGenFlag(JZ_FLAGCODE_SET, JZ_FLAGCODE_OFF); 136 Megaphone_MegDataGenFlag(JZ_FLAGCODE_SET, JZ_FLAGCODE_OFF);
@@ -132,9 +139,15 @@ T_JZsdkReturnCode RealTimeMP2_Close() @@ -132,9 +139,15 @@ T_JZsdkReturnCode RealTimeMP2_Close()
132 int amplifier = JZ_FLAGCODE_OFF; 139 int amplifier = JZ_FLAGCODE_OFF;
133 Megaphone_Amplifier_param(JZ_FLAGCODE_SET, &amplifier); 140 Megaphone_Amplifier_param(JZ_FLAGCODE_SET, &amplifier);
134 141
135 - //关闭音频库  
136 AudioDeal_StopDeal(); 142 AudioDeal_StopDeal();
137 143
  144 + //等候mp2全部关闭
  145 + while ((MP2_Loop_Flag == JZ_FLAGCODE_ON) )//| (MP2_Write_Flag == JZ_FLAGCODE_ON))
  146 + {
  147 + JZSDK_LOG_DEBUG("等待mp2关闭 Lopp:%d Write:%d", MP2_Loop_Flag, MP2_Write_Flag);
  148 + delayMs(100);
  149 + }
  150 +
138 return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS; 151 return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
139 } 152 }
140 153
@@ -169,14 +182,15 @@ static T_JZsdkReturnCode RealTimeMP2_Play_init() @@ -169,14 +182,15 @@ static T_JZsdkReturnCode RealTimeMP2_Play_init()
169 //解码并播放 182 //解码并播放
170 static T_JZsdkReturnCode RealTimeMP2_PlayData(unsigned char *data,int len) 183 static T_JZsdkReturnCode RealTimeMP2_PlayData(unsigned char *data,int len)
171 { 184 {
172 - unsigned char playFile[len];  
173 -  
174 - //清空  
175 - memset(playFile, 0, len);  
176 -  
177 - memcpy(playFile, data, len); 185 + T_JZsdkReturnCode ret = AudioDeal_Mp3DataInput(8000, data, len);
  186 + if (ret == JZ_ERROR_SYSTEM_MODULE_CODE_HARDLY_FAILURE)
  187 + {
  188 + JZSDK_LOG_ERROR("严重错误，清空缓冲区");
  189 + RealTimeMP2_ClearLoop();
  190 + return JZ_ERROR_SYSTEM_MODULE_CODE_HARDLY_FAILURE;
  191 + }
178 192
179 - AudioDeal_Mp3DataInput(8000, playFile, len); 193 + //printf("播放结束\n");
180 194
181 return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS; 195 return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
182 } 196 }
@@ -191,7 +205,7 @@ static void *RealTimeMP2_LoopPlay(void *arg) @@ -191,7 +205,7 @@ static void *RealTimeMP2_LoopPlay(void *arg)
191 205
192 //设立缓冲区域 206 //设立缓冲区域
193 int range = 0; 207 int range = 0;
194 - while (range < 15) // 1.5s 208 + while (range < 15 && RealTimeMP2s_PlayData_LoopReadFlag != JZ_FLAGCODE_OFF) // 1.5s
195 { 209 {
196 range = (RealTimeMP2_PlayData_LoopEnd-RealTimeMP2_PlayData_LoopHead); 210 range = (RealTimeMP2_PlayData_LoopEnd-RealTimeMP2_PlayData_LoopHead);
197 if (range < 0) 211 if (range < 0)
@@ -200,7 +214,7 @@ static void *RealTimeMP2_LoopPlay(void *arg) @@ -200,7 +214,7 @@ static void *RealTimeMP2_LoopPlay(void *arg)
200 } 214 }
201 } 215 }
202 216
203 - printf("开始播放函数\n"); 217 + //printf("开始播放函数\n");
204 218
205 while(RealTimeMP2s_PlayData_LoopReadFlag != JZ_FLAGCODE_OFF) 219 while(RealTimeMP2s_PlayData_LoopReadFlag != JZ_FLAGCODE_OFF)
206 { 220 {
@@ -212,8 +226,11 @@ static void *RealTimeMP2_LoopPlay(void *arg) @@ -212,8 +226,11 @@ static void *RealTimeMP2_LoopPlay(void *arg)
212 RealTimeMP2_PlayData_LoopHead++; 226 RealTimeMP2_PlayData_LoopHead++;
213 RealTimeMP2_PlayLoop_HeadReset(); //池满判断 227 RealTimeMP2_PlayLoop_HeadReset(); //池满判断
214 } 228 }
  229 +
215 } 230 }
216 231
  232 + MP2_Loop_Flag = JZ_FLAGCODE_OFF;
  233 +
217 } 234 }
218 235
219 // 池子头部到底了，重置池头 236 // 池子头部到底了，重置池头
@@ -284,7 +301,7 @@ static void *RealTimeMP2_WriteData_Task(void *arg) @@ -284,7 +301,7 @@ static void *RealTimeMP2_WriteData_Task(void *arg)
284 { 301 {
285 302
286 int ret; 303 int ret;
287 - JZSDK_LOG_DEBUG("MP2实施喊话,输入数据缓冲线程建立"); 304 + printf("MP2实施喊话,输入数据缓冲线程建立\n");
288 RealTimeMP2_WriteFlag = JZ_FLAGCODE_ON; 305 RealTimeMP2_WriteFlag = JZ_FLAGCODE_ON;
289 306
290 while(RealTimeMP2_WriteFlag == JZ_FLAGCODE_ON) 307 while(RealTimeMP2_WriteFlag == JZ_FLAGCODE_ON)
@@ -305,6 +322,8 @@ static void *RealTimeMP2_WriteData_Task(void *arg) @@ -305,6 +322,8 @@ static void *RealTimeMP2_WriteData_Task(void *arg)
305 pthread_cond_signal(&RealTimeMP2_WriteCond); 322 pthread_cond_signal(&RealTimeMP2_WriteCond);
306 pthread_mutex_unlock(&RealTimeMP2_WriteDataLock); 323 pthread_mutex_unlock(&RealTimeMP2_WriteDataLock);
307 } 324 }
  325 +
  326 + MP2_Write_Flag = JZ_FLAGCODE_OFF;
308 } 327 }
309 328
310 //写入数据缓存池重置 329 //写入数据缓存池重置
@@ -449,5 +468,7 @@ static T_JZsdkReturnCode RealTimeMP2_WriteDataToLoop(unsigned char *buf,int leng @@ -449,5 +468,7 @@ static T_JZsdkReturnCode RealTimeMP2_WriteDataToLoop(unsigned char *buf,int leng
449 * **************/ 468 * **************/
450 T_JZsdkReturnCode RealTimeMP2_GetStatusFlag() 469 T_JZsdkReturnCode RealTimeMP2_GetStatusFlag()
451 { 470 {
  471 +
  472 +
452 return RealTimeMp2_StatusFlag; 473 return RealTimeMp2_StatusFlag;
453 } 474 }
@@ -75,7 +75,6 @@ T_JZsdkReturnCode OpusFile_FlushList() @@ -75,7 +75,6 @@ T_JZsdkReturnCode OpusFile_FlushList()
75 OpusFile_FreeAudioList(); 75 OpusFile_FreeAudioList();
76 } 76 }
77 77
78 -  
79 while ((entry = readdir(dir)) != NULL) 78 while ((entry = readdir(dir)) != NULL)
80 { 79 {
81 const unsigned char *filename = entry->d_name; 80 const unsigned char *filename = entry->d_name;
@@ -153,14 +152,6 @@ T_JZsdkReturnCode OpusFile_FlushList() @@ -153,14 +152,6 @@ T_JZsdkReturnCode OpusFile_FlushList()
153 return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS; 152 return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
154 } 153 }
155 154
156 -  
157 -  
158 -  
159 -  
160 -  
161 -  
162 -  
163 -  
164 /********* 155 /*********
165 * 156 *
166 * opus文件初始化 157 * opus文件初始化
@@ -168,6 +159,6 @@ T_JZsdkReturnCode OpusFile_FlushList() @@ -168,6 +159,6 @@ T_JZsdkReturnCode OpusFile_FlushList()
168 **********/ 159 **********/
169 T_JZsdkReturnCode Megaphone_OpusFile_Init() 160 T_JZsdkReturnCode Megaphone_OpusFile_Init()
170 { 161 {
171 - //刷新opus列表 162 + //刷新opus列表(用于加载新的opus文件)
172 OpusFile_FlushList(); 163 OpusFile_FlushList();
173 } 164 }
  1 +/**
  2 + ********************************************************************
  3 + * @file OpusFile.h
  4 + * OpusFile.c OpusFileSave.c 的头文件
  5 + *
  6 + *********************************************************************
  7 + */
  8 +
  9 +/* Define to prevent recursive inclusion 避免重定义 -------------------------------------*/
  10 +#ifndef OPUS_FILE_H
  11 +#define OPUS_FILE_H
  12 +
  13 +/* Includes ------------------------------------------------------------------*/
  14 +#include "JZsdk_Base/JZsdk_Code/JZsdk_Code.h"
  15 +
  16 +#ifdef __cplusplus
  17 +extern "C" {
  18 +#endif
  19 +
  20 +/* Exported constants --------------------------------------------------------*/
  21 +/* 常亮定义*/
  22 +
  23 +/* Exported types ------------------------------------------------------------*/
  24 +
  25 +/* Exported functions --------------------------------------------------------*/
  26 +T_JZsdkReturnCode Megaphone_OpusFile_Init();
  27 +T_JZsdkReturnCode OpusFile_FlushList();
  28 +T_JZsdkReturnCode OpusFile_DecodeOpus(unsigned char *opusFile);
  29 +
  30 +
  31 +T_JZsdkReturnCode OpusFile_SaveOpusFileStart(unsigned char *FileName);
  32 +T_JZsdkReturnCode OpusFile_SaveOpusFileStream(unsigned char *Stream, int StreamLen);
  33 +T_JZsdkReturnCode OpusFile_SaveOpusFileEnd(int CheckFlag, unsigned char *CheckCode, int SaveFlag);
  34 +
  35 +#ifdef __cplusplus
  36 +}
  37 +#endif
  38 +
  39 +#endif
  1 +#include "JZsdkLib.h"
  2 +
  3 +#include "../../Megaphone.h"
  4 +#include "../Megaphone_Opus.h"
  5 +#include "version_choose.h"
  6 +#include "BaseConfig.h"
  7 +
  8 +#include "AudioDeal/AudioDeal.h"
  9 +
  10 +#include "opus.h"
  11 +
  12 +#define OPUS_MAX_FRAME_SIZE (6 * 960)
  13 +#define OPUS_CHANNELS (1)
  14 +#define OPUS_MAX_PACKET_SIZE (3 * 1276)
  15 +
  16 +#define PCM_PLAY_FILE_NAME "/root/test_audio.pcm" //用于播放的pcm
  17 +
  18 +#define PCM_RATE 16000 //解码得到的pcm码率 目前仅支持16000码率
  19 +static int g_opus_decodeBitrate = 16000; //解码码率
  20 +
  21 +static int g_Opus_play_Flag = JZ_FLAGCODE_OFF; //opus的播放标志位
  22 +static int g_Opus_decode_Flag = JZ_FLAGCODE_OFF; //opus的解码标志位
  23 +static T_JZTaskHandle g_DecodeOpus_task = NULL;
  24 +static T_JZTaskHandle g_OpusPlay_task = NULL;
  25 +
  26 +/***************************************************************************************************************
  27 + *
  28 + * 播放部分
  29 + *
  30 + *
  31 +****************************************************************************************************************/
  32 +
  33 +
  34 +static T_JZsdkReturnCode FixedFilePlay()
  35 +{
  36 + FILE *PlayFixedFile_pcm_fp = NULL;
  37 + unsigned int nbBytes;
  38 + uint8_t cbits[3 * 1276];
  39 + int timeNum = 0;
  40 + int loop = JZ_FLAGCODE_OFF;
  41 + int loop_interval;
  42 +
  43 + if(g_Opus_decode_Flag != JZ_FLAGCODE_OFF)
  44 + {
  45 + JZSDK_LOG_ERROR("opus解码超时,无法播放");
  46 + return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
  47 + }
  48 +
  49 + g_Opus_play_Flag = JZ_FLAGCODE_ON;
  50 +
  51 + JZSDK_LOG_INFO("播放指定位置的opus pcm文件\n");
  52 + PlayFixedFile_pcm_fp = fopen(PCM_PLAY_FILE_NAME, "r");
  53 + if (PlayFixedFile_pcm_fp == NULL)
  54 + {
  55 + JZSDK_LOG_ERROR("打开固定opus pcm文件失败\n");
  56 + return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
  57 + }
  58 +
  59 + // 将文件指针移动到文件开头
  60 + if (fseek(PlayFixedFile_pcm_fp, 0, SEEK_SET) != 0)
  61 + {
  62 + JZSDK_LOG_ERROR("Failed to move file pointer to the beginning of the file");
  63 + fclose(PlayFixedFile_pcm_fp);
  64 + return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
  65 + }
  66 +
  67 + while (Megaphone_MegDataGenFlag(JZ_FLAGCODE_GET, 0) == JZ_FLAGCODE_ON)
  68 + {
  69 + nbBytes = fread(cbits, 1, 3 * 1276, PlayFixedFile_pcm_fp);
  70 + if(nbBytes > 0)
  71 + {
  72 + AudioDeal_PcmDataInput(PCM_RATE, (unsigned char *)cbits, nbBytes);
  73 + }
  74 + if (feof(PlayFixedFile_pcm_fp))
  75 + {
  76 + //如果循环播放没打开
  77 + Megaphone_param(JZ_FLAGCODE_GET, MEGAPHONE_LOOP, &loop);
  78 + Megaphone_param(JZ_FLAGCODE_GET, MEGAPHONE_LOOP_INTERVAL, &loop_interval);
  79 +
  80 + if (loop == JZ_FLAGCODE_OFF)
  81 + {
  82 + timeNum = 0;
  83 +
  84 + // //播放结束延迟
  85 + // while ((timeNum <=3000) && (Megaphone_MegDataGenFlag(JZ_FLAGCODE_GET, 0) == JZ_FLAGCODE_ON))
  86 + // {
  87 + // delayMs(10);
  88 + // timeNum +=10;
  89 + // }
  90 +
  91 + break;
  92 + }
  93 + //如果循环播放打开
  94 + else if (loop == JZ_FLAGCODE_ON)
  95 + {
  96 + timeNum = 0;
  97 + JZSDK_LOG_INFO("循环播放opus");
  98 +
  99 + // //播放结束延迟
  100 + // while ((loop == 1) && (Megaphone_MegDataGenFlag(JZ_FLAGCODE_GET, 0) == JZ_FLAGCODE_ON))
  101 + // {
  102 + // delayMs(10);
  103 + // timeNum +=10;
  104 + // }
  105 +
  106 + //重置文件光标 继续播放
  107 + fseek(PlayFixedFile_pcm_fp, 0, SEEK_SET);
  108 +
  109 + //循环播放延时
  110 + while (loop_interval > 0 && (loop == JZ_FLAGCODE_ON) && (Megaphone_MegDataGenFlag(JZ_FLAGCODE_GET, 0) == JZ_FLAGCODE_ON))
  111 + {
  112 + delayMs(50);
  113 + loop_interval -= 50;
  114 + }
  115 +
  116 + continue;
  117 + }
  118 + }
  119 + }
  120 +
  121 + fclose(PlayFixedFile_pcm_fp);
  122 +
  123 + g_Opus_play_Flag = JZ_FLAGCODE_OFF;
  124 +}
  125 +
  126 +/*
  127 +*
  128 +* 播放固定位置pcm线程
  129 +*
  130 +*/
  131 +static void *PlayFixedFile_task(void *arg)
  132 +{
  133 + Megaphone_MegDataGenFlag(JZ_FLAGCODE_SET, JZ_FLAGCODE_ON);
  134 + Megaphone_MegDataGenFinshFlag(JZ_FLAGCODE_SET, JZ_FLAGCODE_ON);
  135 +
  136 + //广播开始
  137 + Megaphone_status_Broadcast(AUDIO_PLAY_STATUS_OPUS_RECORD);
  138 +
  139 + int amplifier = JZ_FLAGCODE_ON;
  140 + Megaphone_Amplifier_param(JZ_FLAGCODE_SET, &amplifier);
  141 +
  142 + FixedFilePlay();
  143 +
  144 + amplifier = JZ_FLAGCODE_OFF;
  145 + Megaphone_Amplifier_param(JZ_FLAGCODE_SET, &amplifier);
  146 +
  147 + Megaphone_MegDataGenFlag(JZ_FLAGCODE_SET, JZ_FLAGCODE_OFF);
  148 + Megaphone_MegDataGenFinshFlag(JZ_FLAGCODE_SET, JZ_FLAGCODE_OFF);
  149 +
  150 + //广播关闭
  151 + Megaphone_status_Broadcast(JZ_FLAGCODE_OFF);
  152 +}
  153 +
  154 +/*******************************
  155 +*
  156 +* 播放规定位置的opus文件
  157 +* 旧接口，无需定位传入的位置
  158 +*
  159 +************************************/
  160 +T_JZsdkReturnCode OpusFile_PlayFixedFile()
  161 +{
  162 + T_JZsdkOsalHandler *OsalHandler = JZsdk_Platform_GetOsalHandler();
  163 +
  164 + OsalHandler->TaskCreate("PiayFilexdFile", PlayFixedFile_task, 8192, NULL, &g_DecodeOpus_task);
  165 +
  166 + return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
  167 +}
  168 +
  169 +
  170 +
  171 +/*************************************************************************************************************/
  172 +
  173 +/*
  174 +
  175 + 解码函数
  176 +
  177 +
  178 +*/
  179 +static T_JZsdkReturnCode OpusDecodeFun(unsigned char *OpusFile)
  180 +{
  181 + FILE *fin = NULL;
  182 + FILE *fout = NULL;
  183 + OpusDecoder *decoder;
  184 + opus_int16 out[OPUS_MAX_FRAME_SIZE * OPUS_CHANNELS];
  185 + uint8_t cbits[OPUS_MAX_PACKET_SIZE];
  186 + int32_t nbBytes;
  187 + int32_t err;
  188 +
  189 + if (g_Opus_decode_Flag != JZ_FLAGCODE_OFF)
  190 + {
  191 + return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
  192 + }
  193 +
  194 + g_Opus_decode_Flag = JZ_FLAGCODE_ON;
  195 +
  196 + printf("Decode Start 解码开始\n"); //解码开始
  197 +
  198 + //打开解码的opus文件
  199 + //TODO: need delete
  200 + //attention: you can use "ffmpeg -i xxx.mp3 -ar 16000 -ac 1 out.wav" and "./test_opus_tool out.wav out.opus" to generate opus file to test
  201 + fin = fopen(OpusFile, "r");
  202 + if (fin == NULL) {
  203 + JZSDK_LOG_ERROR("fin打开失败");
  204 + goto DecodeFinsh;
  205 + }
  206 +
  207 + //创建一个解码器
  208 + decoder = opus_decoder_create(PCM_RATE, OPUS_CHANNELS, &err);
  209 + if (err < 0) {
  210 + JZSDK_LOG_ERROR("解码器创建失败 %s",opus_strerror(err));
  211 + goto DecodeFinsh;
  212 + }
  213 +
  214 + //创建一个opus输出文件
  215 + fout = fopen(PCM_PLAY_FILE_NAME, "w");
  216 + if (fout == NULL) {
  217 + JZSDK_LOG_ERROR("创建opus输出文件失败");
  218 + goto DecodeFinsh;
  219 + }
  220 +
  221 + printf("opus解码初始化完成\n");
  222 +
  223 + int frame_size;
  224 +
  225 + while (1)
  226 + {
  227 + int i;
  228 + opus_int16 TempPcm[OPUS_MAX_FRAME_SIZE * OPUS_CHANNELS];
  229 +
  230 + frame_size = 0;
  231 +
  232 + //读取opus内容
  233 + /* Read a 16 bits/sample audio frame. */
  234 + nbBytes = fread(cbits, 1, g_opus_decodeBitrate / 8000 * 40, fin);
  235 + if (feof(fin))
  236 + {
  237 + break;
  238 + }
  239 +
  240 + printf("fread nbBytes=%d\n",nbBytes);
  241 + //printf("s_decodeBitrate=%d",s_decodeBitrate / OPUS_DECODE_BITRATE_8KBPS * OPUS_DECODE_FRAME_SIZE_8KBPS);
  242 + /* Decode the data. In this example, frame_size will be constant because
  243 + the encoder is using a constant frame size. However, that may not
  244 + be the case for all encoders, so the decoder must always check
  245 + the frame size returned. */
  246 +
  247 + //向解码器输入opus内容
  248 + frame_size = opus_decode(decoder, cbits, nbBytes, out, OPUS_MAX_FRAME_SIZE, 0);
  249 + if (frame_size < 0) {
  250 + JZSDK_LOG_ERROR("decoder failed: %s",opus_strerror(frame_size));
  251 + goto DecodeFinsh;
  252 + }
  253 +
  254 + //解码完成
  255 + printf("decode data to file: %d\r\n", frame_size * OPUS_CHANNELS);
  256 + /* Convert to little-endian ordering. */
  257 +
  258 + for (i = 0; i < OPUS_CHANNELS * frame_size; i++) {
  259 + TempPcm [i] = out[i] & 0xFF | (out[i] >> 8) << 8;
  260 + //TempPcm[i] = PcmNoiseReduction(TempPcm[i]);
  261 + }
  262 +
  263 + fwrite(TempPcm, sizeof(short), frame_size * OPUS_CHANNELS, fout);
  264 +
  265 + }
  266 +
  267 +DecodeFinsh:
  268 +
  269 + //释放解码器
  270 + if (decoder != NULL)
  271 + {
  272 + opus_decoder_destroy(decoder);
  273 + printf("opus_decoder_destroy(decoder)\n");
  274 + }
  275 +
  276 + //关闭文件
  277 + if (fin != NULL)
  278 + {
  279 + fclose(fin);
  280 + fin = NULL;
  281 + printf("fclose(fin);\n");
  282 + }
  283 +
  284 + //关闭文件
  285 + if (fout != NULL)
  286 + {
  287 + fclose(fout);
  288 + fout = NULL;
  289 + printf("fclose(fout);\n");
  290 + }
  291 +
  292 + if (frame_size < 0)
  293 + {
  294 + JZSDK_LOG_ERROR("opus解码失败");
  295 + g_Opus_decode_Flag = JZ_FLAGCODE_OFF;
  296 + return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
  297 + }
  298 +
  299 + //解码完成
  300 + JZSDK_LOG_INFO("Decode Finished...\n");
  301 + g_Opus_decode_Flag = JZ_FLAGCODE_OFF;
  302 + return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
  303 +}
  304 +
  305 +/*******************
  306 +*
  307 +* opus解码线程
  308 +*
  309 +*******************/
  310 +static void *DecodeOpus_task(void *arg)
  311 +{
  312 + unsigned char *opusFile = (unsigned char *)arg;
  313 +
  314 + T_JZsdkReturnCode ret = OpusDecodeFun(opusFile);
  315 + if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
  316 + {
  317 + //广播解码失败
  318 + Megaphone_Broadcast_OpusDecodeStatus(1);
  319 + }
  320 + else
  321 + {
  322 + Megaphone_Broadcast_OpusDecodeStatus(0);
  323 + }
  324 +
  325 + free(opusFile);
  326 +}
  327 +
  328 +T_JZsdkReturnCode OpusFile_DecodeOpus(unsigned char *opusFile)
  329 +{
  330 + T_JZsdkOsalHandler *OsalHandler = JZsdk_Platform_GetOsalHandler();
  331 +
  332 + T_JZsdkReturnCode ret = JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
  333 +
  334 + //因为播放的流通pcm文件只有一份，所以播放时，不能进行解码，不然会导致相当多问题
  335 + int i = 0;
  336 + while (i <= 4 && g_Opus_play_Flag == JZ_FLAGCODE_ON)
  337 + {
  338 + i++;
  339 + delayMs(50);
  340 + }
  341 +
  342 + //判断上一次播放是否结束 判断解码是否完成
  343 + if(i == 4)
  344 + {
  345 + JZSDK_LOG_ERROR("超时200ms,上一次opus录音播放未结束,无法解码");
  346 + return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
  347 + }
  348 +
  349 + i = 0;
  350 + while (i<=4 && g_Opus_decode_Flag == JZ_FLAGCODE_ON)
  351 + {
  352 + i++;
  353 + delayMs(50);
  354 + }
  355 + if(i == 4)
  356 + {
  357 + JZSDK_LOG_ERROR("超时,上一次opus仍在解码,无法开始新的解码");
  358 + return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
  359 + }
  360 +
  361 + unsigned char *DecodeFile = OsalHandler->Malloc(strlen(opusFile));
  362 + if(DecodeFile == NULL)
  363 + {
  364 + JZSDK_LOG_ERROR("DecodeFile malloc failed");
  365 + return JZ_ERROR_SYSTEM_MODULE_CODE_MEMORY_ALLOC_FAILED;
  366 + }
  367 + memset(DecodeFile, strlen(opusFile), 0);
  368 + memcpy(DecodeFile, opusFile, strlen(opusFile));
  369 +
  370 + OsalHandler->TaskCreate("DecodeOpus", DecodeOpus_task((void *)DecodeFile), 8192,NULL, &g_DecodeOpus_task);
  371 +
  372 + return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
  373 +}
1 #include <stdio.h> 1 #include <stdio.h>
2 #include "JZsdkLib.h" 2 #include "JZsdkLib.h"
3 3
  4 +#include "OpusFile.h"
  5 +
4 static int g_OpusFile_SaveLen = 0; 6 static int g_OpusFile_SaveLen = 0;
5 static FILE *g_OpusFile_SaveFp = NULL; 7 static FILE *g_OpusFile_SaveFp = NULL;
6 -static int g_OpusFile_SaveFlag = JZ_FLAGCODE_OFF; 8 +static int g_OpusFile_SaveFlag = JZ_FLAGCODE_OFF; //opus存储标志位
7 9
8 #define OPUS_FILE_DIR "/root/sdcard/opus" 10 #define OPUS_FILE_DIR "/root/sdcard/opus"
9 -#define OPUS_TEMP_SAVE_DIR "/root/opusFileTemp.opus" 11 +#define OPUS_TEMP_SAVE_DIR "/root/test_audio.opus"
10 static unsigned char opus_SaveFile[128]; 12 static unsigned char opus_SaveFile[128];
11 13
12 -static int OpusFile_SaveThread_Flag = JZ_FLAGCODE_OFF; 14 +static T_JZTaskHandle s_OpusSaveThread = NULL;
13 15
14 /****************** 16 /******************
15 * 17 *
@@ -18,19 +20,21 @@ static int OpusFile_SaveThread_Flag = JZ_FLAGCODE_OFF; @@ -18,19 +20,21 @@ static int OpusFile_SaveThread_Flag = JZ_FLAGCODE_OFF;
18 * 20 *
19 * 21 *
20 * **********************/ 22 * **********************/
21 -static T_JZsdkReturnCode OpusFile_SaveOpusFileShowLen(void) 23 +static void *OpusFile_SaveOpusPrint(void *arg)
22 { 24 {
23 - if (OpusFile_SaveThread_Flag != JZ_FLAGCODE_OFF) 25 + while (g_OpusFile_SaveFlag == JZ_FLAGCODE_ON)
24 { 26 {
25 - JZSDK_LOG_ERROR("存储显示线程已经启动，请先关闭");  
26 - return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;  
27 - }  
28 -  
29 - OpusFile_SaveThread_Flag = JZ_FLAGCODE_ON; 27 + int num = 0;
30 28
  29 + JZSDK_LOG_INFO("opus存储功能开启中,当前已存入 %d 字节",g_OpusFile_SaveLen);
31 30
32 -  
33 - return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS; 31 + //适时延迟
  32 + while (num < 100 && g_OpusFile_SaveFlag == JZ_FLAGCODE_ON)
  33 + {
  34 + delayMs(10);
  35 + num++;
  36 + }
  37 + }
34 } 38 }
35 39
36 /****************** 40 /******************
@@ -42,6 +46,14 @@ static T_JZsdkReturnCode OpusFile_SaveOpusFileShowLen(void) @@ -42,6 +46,14 @@ static T_JZsdkReturnCode OpusFile_SaveOpusFileShowLen(void)
42 * **********************/ 46 * **********************/
43 T_JZsdkReturnCode OpusFile_SaveOpusFileStart(unsigned char *FileName) 47 T_JZsdkReturnCode OpusFile_SaveOpusFileStart(unsigned char *FileName)
44 { 48 {
  49 + T_JZsdkOsalHandler *OsalHandler = JZsdk_Platform_GetOsalHandler();
  50 +
  51 + if (g_OpusFile_SaveFlag == JZ_FLAGCODE_ON)
  52 + {
  53 + JZSDK_LOG_ERROR("opus文件保存功能已经开启");
  54 + return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
  55 + }
  56 +
45 g_OpusFile_SaveLen = 0; 57 g_OpusFile_SaveLen = 0;
46 58
47 memset(opus_SaveFile, 0, sizeof(opus_SaveFile)); 59 memset(opus_SaveFile, 0, sizeof(opus_SaveFile));
@@ -64,6 +76,9 @@ T_JZsdkReturnCode OpusFile_SaveOpusFileStart(unsigned char *FileName) @@ -64,6 +76,9 @@ T_JZsdkReturnCode OpusFile_SaveOpusFileStart(unsigned char *FileName)
64 76
65 g_OpusFile_SaveFlag = JZ_FLAGCODE_ON; 77 g_OpusFile_SaveFlag = JZ_FLAGCODE_ON;
66 78
  79 + //创建存储显示线程
  80 + OsalHandler->TaskCreate("OpusSavePrint", OpusFile_SaveOpusPrint, 8192,NULL, &s_OpusSaveThread);
  81 +
67 return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS; 82 return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
68 } 83 }
69 84
@@ -107,9 +122,12 @@ T_JZsdkReturnCode OpusFile_SaveOpusFileStream(unsigned char *Stream, int StreamL @@ -107,9 +122,12 @@ T_JZsdkReturnCode OpusFile_SaveOpusFileStream(unsigned char *Stream, int StreamL
107 * 122 *
108 * 结束存储opus文件 123 * 结束存储opus文件
109 * 124 *
  125 + * checkflag是否需要校正 或校正类型
  126 + * checkcode 校正码
  127 + * saveflag 是否需要保存
110 * 128 *
111 * **********************/ 129 * **********************/
112 -T_JZsdkReturnCode OpusFile_SaveOpusFileEnd(int CheckFlag, unsigned char *CheckCode) 130 +T_JZsdkReturnCode OpusFile_SaveOpusFileEnd(int CheckFlag, unsigned char *CheckCode, int SaveFlag)
113 { 131 {
114 T_JZsdkReturnCode ret = JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS; 132 T_JZsdkReturnCode ret = JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
115 unsigned char cmd[128]; 133 unsigned char cmd[128];
@@ -136,15 +154,16 @@ T_JZsdkReturnCode OpusFile_SaveOpusFileEnd(int CheckFlag, unsigned char *CheckCo @@ -136,15 +154,16 @@ T_JZsdkReturnCode OpusFile_SaveOpusFileEnd(int CheckFlag, unsigned char *CheckCo
136 154
137 JZSDK_LOG_INFO("已存储opus文件, 其长度为:%d", g_OpusFile_SaveLen); 155 JZSDK_LOG_INFO("已存储opus文件, 其长度为:%d", g_OpusFile_SaveLen);
138 156
139 - switch (CheckFlag) 157 +/***********************************************************
  158 + *
  159 + * 校验部分
  160 + *
  161 + *
  162 + * *********************************************************/
  163 + if (CheckFlag != JZ_FLAGCODE_OFF)
140 { 164 {
141 - case JZ_FLAGCODE_OFF: 165 + switch (CheckFlag)
142 { 166 {
143 - JZSDK_LOG_INFO("opus保存无需校验码");  
144 - ret = JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;  
145 - }  
146 - break;  
147 -  
148 case JZSDK_CHECK_SUM_TYPE_MD5: 167 case JZSDK_CHECK_SUM_TYPE_MD5:
149 { 168 {
150 JZSDK_LOG_INFO("opus保存使用md5校验码"); 169 JZSDK_LOG_INFO("opus保存使用md5校验码");
@@ -159,6 +178,7 @@ T_JZsdkReturnCode OpusFile_SaveOpusFileEnd(int CheckFlag, unsigned char *CheckCo @@ -159,6 +178,7 @@ T_JZsdkReturnCode OpusFile_SaveOpusFileEnd(int CheckFlag, unsigned char *CheckCo
159 //1、获取文件的src32校验码 178 //1、获取文件的src32校验码
160 ret = JZsdk_CheckSum(JZSDK_CHECK_SUM_TYPE_SRC32, OPUS_TEMP_SAVE_DIR, CheckCode, 4); 179 ret = JZsdk_CheckSum(JZSDK_CHECK_SUM_TYPE_SRC32, OPUS_TEMP_SAVE_DIR, CheckCode, 4);
161 } 180 }
  181 + break;
162 182
163 default: 183 default:
164 { 184 {
@@ -178,6 +198,55 @@ T_JZsdkReturnCode OpusFile_SaveOpusFileEnd(int CheckFlag, unsigned char *CheckCo @@ -178,6 +198,55 @@ T_JZsdkReturnCode OpusFile_SaveOpusFileEnd(int CheckFlag, unsigned char *CheckCo
178 198
179 return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE; 199 return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
180 } 200 }
  201 + }
  202 + else
  203 + {
  204 + JZSDK_LOG_INFO("opus保存无需校验码");
  205 + }
181 206
  207 +/***********************************************************
  208 + *
  209 + * 额外存储部分
  210 + *
  211 + *
  212 + * *********************************************************/
  213 + if (SaveFlag != JZ_FLAGCODE_OFF)
  214 + {
  215 + //将临时的opus文件移动到指定的目录
  216 + memset(cmd, 0, sizeof(cmd));
  217 + sprintf(cmd, "mv %s %s", OPUS_TEMP_SAVE_DIR, opus_SaveFile);
  218 + ret = JZsdk_RunSystemCmd(cmd);
  219 + if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
  220 + {
  221 + JZSDK_LOG_ERROR("opus保存文件移动失败");
  222 + memset(cmd, 0, sizeof(cmd));
  223 + sprintf(cmd, "rm -rf %s", OPUS_TEMP_SAVE_DIR);
  224 + JZsdk_RunSystemCmd(cmd);
  225 + g_OpusFile_SaveFlag = JZ_FLAGCODE_OFF;
182 226
  227 + return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
  228 + }
  229 +
  230 + //移动成功
  231 + JZsdk_Sync(); //同步文件系统
  232 + JZSDK_LOG_INFO("opus保存成功,刷新列表");
  233 + OpusFile_FlushList(); //刷新opus文件列表
  234 + }
  235 +/********************************************************************
  236 + *
  237 + *
  238 + * 如果不进行额存储，则进行一次opus解码
  239 + *
  240 + *
  241 +/********************************************************************/
  242 + else
  243 + {
  244 + OpusFile_DecodeOpus(opus_SaveFile);
  245 + }
  246 +
  247 + JZSDK_LOG_INFO("opus_save_end");
  248 +
  249 + g_OpusFile_SaveFlag = JZ_FLAGCODE_OFF;
  250 +
  251 + return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
183 } 252 }
@@ -189,7 +189,7 @@ static const T_DjiWidgetHandlerListItem s_widgetHandlerList[] = { @@ -189,7 +189,7 @@ static const T_DjiWidgetHandlerListItem s_widgetHandlerList[] = {
189 }; 189 };
190 190
191 static const uint32_t s_widgetHandlerListCount = sizeof(s_widgetHandlerList) / sizeof(T_DjiWidgetHandlerListItem); 191 static const uint32_t s_widgetHandlerListCount = sizeof(s_widgetHandlerList) / sizeof(T_DjiWidgetHandlerListItem);
192 -int32_t s_widgetValueList[] = {VIDEOMGMT_STREAMING_FLOW_INDEX_FIRST, //视频流 192 +int32_t s_widgetValueList[] = {VIDEOMGMT_STREAMING_FLOW_INDEX_THIRD, //视频流
193 OFF, //测温模式 193 OFF, //测温模式
194 ON, //光圈开关 194 ON, //光圈开关
195 OFF, //冻结开关 195 OFF, //冻结开关