toy/AW-Security-Media-Lib
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

feat/hk #1

Merged
tqcq merged 8 commits from feat/hk into dev 2024-09-04 10:34:35 +08:00
Conversation 0 Commits 8 Files Changed 22 +3288 -618
20 changed files with 3288 additions and 618 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit db52928975 - Show all commits

12
CMakeLists.txt
View File

@ -1,6 +1,7 @@
cmake_minimum_required(VERSION 3.9)
project(
SecMedia
LANGUAGES C CXX
VERSION 0.0.1
DESCRIPTION "Security Media Package")
set(CMAKE_CXX_STANDARD 11)
@ -83,13 +84,20 @@ file(
${SecMedia_Root}/*/*.c
${SecMedia_Root}/*/*/*.cpp
${SecMedia_Root}/*/*/*.h
${SecMedia_Root}/*/*/*.c)
${SecMedia_Root}/*/*/*.c
)
file(GLOB SecMedia_api_list ${CMAKE_CURRENT_SOURCE_DIR}/include/common.h)
# # target_compile_options(${PROJECT_NAME} PRIVATE -fvisibility=hidden)
# list(APPEND LINK_LIB_LIST ${LINK_LIB_SVAC_LIST})
add_library(${PROJECT_NAME} SHARED ${SecMedia_src_list})
add_library(${PROJECT_NAME} SHARED
"src/base/util.cpp"
"src/base/rtp_packet.cpp"
"src/SVAC/src/sm2sm3/sm3.c"
"src/SVAC/src/sm2sm3/sm2.c"
${SecMedia_src_list}
)
# add_library(${PROJECT_NAME} STATIC ${SecMedia_src_list})
target_link_libraries(${PROJECT_NAME} ${LINK_LIB_SVAC_LIST} rtp)
target_include_directories(${PROJECT_NAME} PRIVATE ${SecMedia_Root}/.)

136
PcapSender/main.cpp
View File

@ -1,14 +1,15 @@
#include <iostream>
#include "HuaWei/HWsec.h"
#include "HuaWei/HWsign.h"
#include <Packet.h>
#include <PcapFileDevice.h>
#include <UdpLayer.h>
#include <string>
#include <arpa/inet.h>
#include <atomic>
#include <iostream>
#include <stdio.h>
#include <sys/socket.h>
#include <string>
#include <sys/select.h>
#include "HuaWei/HWsign.h"
#include "HuaWei/HWsec.h"
#include <sys/socket.h>
using namespace std;
using namespace pcpp;
@ -18,27 +19,28 @@ sec_set_info sign_info={
"2021-07-06T17:27:19.000",
32,
64,
{
0x24,0x88,0xc8,0xdc,0x7f,0xd7,0xe0,0x91,0x30,0x1b,0x5c,0x58,0x2f,0xe7,0x44,0x7d,
0x2f,0x43,0xe4,0xee,0xc8,0x7d,0xc0,0xfb,0xa4,0xb8,0x7d,0x4b,0x8a,0x69,0x7c,0x4e
},
{0x24, 0x88, 0xc8, 0xdc, 0x7f, 0xd7, 0xe0, 0x91, 0x30, 0x1b, 0x5c, 0x58, 0x2f, 0xe7, 0x44, 0x7d,
0x2f, 0x43, 0xe4, 0xee, 0xc8, 0x7d, 0xc0, 0xfb, 0xa4, 0xb8, 0x7d, 0x4b, 0x8a, 0x69, 0x7c, 0x4e},
{
0xaa, 0xb1, 0x3f, 0xd7, 0x66, 0xe2, 0x75, 0x97, 0xc0, 0x03, 0xe6, 0xe4, 0x1d, 0x77, 0x54, 0x78,
0xc8, 0x29, 0xb2, 0x0b, 0x9e, 0xd1, 0xff, 0xa3, 0x6a, 0x6f, 0xd2, 0x7f, 0xd6, 0x2d, 0xaa, 0x3f,
0xc9, 0x24, 0xec, 0x6c, 0x96, 0x0a, 0x7b, 0x73, 0xf6, 0xe6, 0xfc, 0xda, 0x3a, 0x08, 0xfd, 0x92,
0xfc, 0x00, 0x08, 0x97, 0x78, 0x2c, 0x71, 0x6b, 0xe1, 0x26, 0xf5, 0x1e, 0xba, 0x31, 0xf5, 0xb2,
}
};
void * EncrypInit(){
}};
void *
EncrypInit()
{
// auto Verify_handle=HWVerify_init();
auto sign_handle = GB28181_stream_init(&sign_info);//HWSign_init(&sign_info);
return sign_handle;
}
std::string getProtocolTypeAsString(pcpp::ProtocolType protocolType)
{
switch (protocolType)
std::string
getProtocolTypeAsString(pcpp::ProtocolType protocolType)
{
switch (protocolType) {
case pcpp::Ethernet:
return "Ethernet";
case pcpp::IPv4:
@ -53,15 +55,19 @@ std::string getProtocolTypeAsString(pcpp::ProtocolType protocolType)
default:
return "Unknown";
}
}
inline void sleep(timeval & delta){
inline void
sleep(timeval &delta)
{
// delta.tv_sec
select(0, NULL, NULL, NULL, &delta);
}
template<typename T, typename U>
timespec TimeDiff(T && minu,U && sub){
timespec
TimeDiff(T &&minu, U &&sub)
{
timespec deltatime;
deltatime.tv_nsec = minu.tv_nsec - sub.tv_nsec;
deltatime.tv_sec = minu.tv_sec - sub.tv_sec;
@ -72,24 +78,23 @@ timespec TimeDiff(T && minu,U && sub){
return move(deltatime);
}
int ReadPcapAndSend(int socket,sockaddr_in & addr,const string & filename,const string & filter,void * sign_handle){
int
ReadPcapAndSend(int socket, sockaddr_in &addr, const string &filename, const string &filter, void *sign_handle)
{
// auto sign_h2=EncrypInit();
auto reader = pcpp::IFileReaderDevice::getReader(filename);
// verify that a reader interface was indeed created
if (reader == NULL)
{
if (reader == NULL) {
std::cerr << "Cannot determine reader for file type" << std::endl;
return 1;
}
// open the reader for reading
if (!reader->open())
{
if (!reader->open()) {
std::cerr << "Cannot open input.pcap for reading" << std::endl;
return 1;
}
if (!reader->setFilter(filter))
{
if (!reader->setFilter(filter)) {
std::cerr << "Cannot set filter for file reader" << std::endl;
return 1;
}
@ -105,8 +110,30 @@ int ReadPcapAndSend(int socket,sockaddr_in & addr,const string & filename,const
unsigned int sign_out_len;
void *param = nullptr;
uint16_t offset_len, append_len;
while (reader->getNextPacket(rawPacket))
{
std::shared_ptr<std::thread> output_thread;
std::atomic<bool> processing{true};
std::atomic<int> processing_cnt{0};
if (sign_handle) {
output_thread = std::shared_ptr<std::thread>(new std::thread([&] {
while (processing.load(std::memory_order_relaxed)) {
int ret =
GB28181_stream_out(sign_handle, sign_out_buf, &sign_out_len, &offset_len, &append_len, &param);
if (ret != 1) { continue; }
processing_cnt.fetch_sub(1);
if (append_len == 0) {
sendto(socket, sign_out_buf, sign_out_len, 0, (const sockaddr *) &addr, sizeof(addr));
} else {
sendto(socket, sign_out_buf, offset_len, 0, (const sockaddr *) &addr, sizeof(addr));
sendto(socket, sign_out_buf + offset_len, sign_out_len - offset_len, 0, (const sockaddr *) &addr,
sizeof(addr));
}
// GB28181_stream_in(sign_h2,(char*)payload,payload_len,nullptr);
// GB28181_stream_out(sign_h2,sign_out_buf,&sign_out_len,&offset_len,&append_len, &param);
}
}));
}
while (reader->getNextPacket(rawPacket)) {
pcpp::Packet parsedPacket(&rawPacket, OsiModelTransportLayer);
auto layer = parsedPacket.getLayerOfType<UdpLayer>(false);
@ -123,43 +150,34 @@ int ReadPcapAndSend(int socket,sockaddr_in & addr,const string & filename,const
current_time.tv_sec = inital_time.tv_sec + real_now.tv_sec;
current_time.tv_nsec = inital_time.tv_nsec + real_now.tv_nsec;
gaptime = TimeDiff(nowtime, current_time);
if (gaptime.tv_nsec>=0 && gaptime.tv_sec>=0)
{
if (gaptime.tv_nsec >= 0 && gaptime.tv_sec >= 0) {
nanosleep(&gaptime, NULL);
} else {
// cout<<" s:" << gaptime.tv_sec<<" ns:" << gaptime.tv_nsec <<endl;
}
// ///////////////calculate send time//////////////////
if (sign_handle) {
auto cnt = processing_cnt.fetch_add(1);
// printf("frame processing cnt:%d\n", cnt);
GB28181_stream_in(sign_handle, (char *) payload, payload_len, nullptr);
GB28181_stream_out(sign_handle,sign_out_buf,&sign_out_len,&offset_len,&append_len, &param);
if (append_len==0)
{
sendto(socket,sign_out_buf,sign_out_len,0,(const sockaddr*)&addr,sizeof(addr));
}else
{
sendto(socket,sign_out_buf,offset_len,0,(const sockaddr*)&addr,sizeof(addr));
sendto(socket,sign_out_buf+offset_len,sign_out_len-offset_len,0,(const sockaddr*)&addr,sizeof(addr));
}
// GB28181_stream_in(sign_h2,(char*)payload,payload_len,nullptr);
// GB28181_stream_out(sign_h2,sign_out_buf,&sign_out_len,&offset_len,&append_len, &param);
} else {
if (sendto(socket, payload, payload_len, 0, (const sockaddr *) &addr, sizeof(addr)) == -1) {
printf("send failed : %s\n", strerror(errno));
}
}
}
// cout<<" stamp:" << rawPacket.getPacketTimeStamp().tv_sec<<" len:"<< rawPacket.getRawDataLen()<<endl;
}
if (sign_handle) {
while (processing_cnt.load(std::memory_order_relaxed) > 0) {
timeval delta = {0, 100000};
sleep(delta);
}
processing.store(false);
output_thread->join();
}
// reader->getNextPacket(rawPacket);
@ -175,15 +193,18 @@ int ReadPcapAndSend(int socket,sockaddr_in & addr,const string & filename,const
// create the stats object
pcpp::IPcapDevice::PcapStats stats;
reader->getStatistics(stats);
std::cout << "Read " << stats.packetsRecv << " packets successfully and " << stats.packetsDrop << " packets could not be read" << std::flush;
std::cout << "Read " << stats.packetsRecv << " packets successfully and " << stats.packetsDrop
<< " packets could not be read" << std::flush;
return 0;
}
int main(int argc, char *argv[]){
int
main(int argc, char *argv[])
{
char ip[16] = {0};
int sockfd, port;
if (argc>4)
{
if (argc > 4) {
string filename(argv[1]);
strcpy(ip, argv[2]);
port = atoi(argv[3]);
@ -198,13 +219,9 @@ int main(int argc, char *argv[]){
int rcvBufSize = 2097152;
int rcvlen = sizeof(rcvBufSize);
setsockopt(sockfd, SOL_SOCKET, SO_SNDBUF, (char *) &rcvBufSize, sizeof(rcvBufSize));
if (getsockopt(sockfd, SOL_SOCKET, SO_SNDBUF, (char*)&rcvBufSize, (socklen_t *)&rcvlen) >= 0)
{
if (getsockopt(sockfd, SOL_SOCKET, SO_SNDBUF, (char *) &rcvBufSize, (socklen_t *) &rcvlen) >= 0) {
printf("set udp socket send buff size to : %d\n", rcvBufSize);
if (rcvBufSize < 4194304)
{
printf("socket send buff too small, please set up to 2097152(2M)");
}
if (rcvBufSize < 4194304) { printf("socket send buff too small, please set up to 2097152(2M)"); }
} else {
printf("socket failed : %s\n", strerror(errno));
return -1;
@ -226,13 +243,10 @@ int main(int argc, char *argv[]){
ReadPcapAndSend(sockfd, addr, filename, filter, sign_h);
// }
}
else
{
} else {
printf("CMD as: filename.pcap ip port\n");
system("pause");
return 0;
}
return 0;
}

278
src/HuaWei/HWsign.cpp
View File

@ -1,13 +1,13 @@
#include "HuaWei/HWsign.h"
#include "HWcommon.h"
#include "common.h"
#include <arpa/inet.h>
#include <condition_variable>
#include <iostream>
#include <mutex>
#include <thread>
#include <unistd.h>
#include <arpa/inet.h>
#include "common.h"
#include "HWcommon.h"
#include "HuaWei/HWsign.h"
#include "DecEnc/NALUdecode.h"
#include "DecEnc/base64.h"
@ -17,25 +17,22 @@
#include "sm/sm.h"
#endif
void send_rtp(HWsign *Handle, const char *buf, const uint32_t len, int tcp, void *param);
void print_data2(const char * buf, uint32_t len,uint8_t offest){
void
print_data2(const char *buf, uint32_t len, uint8_t offest)
{
printf("\n --%d-- \n", len);
for (int num = 0; num < offest; num++)
{
printf("%02X ", (uint8_t)buf[num]);
}
for (int num = 0; num < offest; num++) { printf("%02X ", (uint8_t) buf[num]); }
printf(", ");
for (int num = offest; num < 20; num++)
{
printf("%02X ", (uint8_t)buf[num]);
}
for (int num = offest; num < 20; num++) { printf("%02X ", (uint8_t) buf[num]); }
printf("\n ---- \n");
}
void print_rtp2(const char * buf, uint32_t len,uint8_t offest){
void
print_rtp2(const char *buf, uint32_t len, uint8_t offest)
{
uint8_t mask = 0;
uint16_t seq = 0;
uint32_t stamp = 0;
@ -49,12 +46,17 @@ void print_rtp2(const char * buf, uint32_t len,uint8_t offest){
}
#ifdef ENABLE_HARDWARE_SIGN
int hardware_sign_l(SM2Config * config,const unsigned char * data_in,const size_t in_len, unsigned char * sign_out, uint16_t * sign_len){
int
hardware_sign_l(SM2Config *config,
const unsigned char *data_in,
const size_t in_len,
unsigned char *sign_out,
uint16_t *sign_len)
{
int rv = 0;
rv = Device_Init();
printf("Device_Init rv = 0x%02x\n", rv);
if(rv != 0)
{
if (rv != 0) {
printf("Device_Init Fail\n");
return -1;
}
@ -62,27 +64,31 @@ int hardware_sign_l(SM2Config * config,const unsigned char * data_in,const size_
unsigned char Hash_Data[35];
unsigned int Hash_Data_len = 32;
rv = Generate_Hash(data_in, (const unsigned int) in_len, Hash_Data, &Hash_Data_len, NULL, SGD_SM3);
if(rv != 0)
{
if (rv != 0) {
printf("Generate_Hash FAIL\n\n");
return -1;
}
else printf("Generate_Hash SUCCESS\n\n");
} else
printf("Generate_Hash SUCCESS\n\n");
unsigned int Sign_Data_len = 65;
*sign_len = Sign_Data_len;
rv = Generate_SignData_ExtPrikey(config->prikey, Hash_Data, Hash_Data_len, sign_out, &Sign_Data_len);
if(rv != 0)
{
if (rv != 0) {
printf("Generate_SignData_ExtPrikey Fail\n");
return 0;
}
else printf("Generate_SignData_ExtPrikey SUCCESS\n");
} else
printf("Generate_SignData_ExtPrikey SUCCESS\n");
return 1;
}
int Hardware_sign(SM2Config * config,const unsigned char * data_in,const size_t in_len, unsigned char * sign_out, uint16_t * sign_len){
int
Hardware_sign(SM2Config *config,
const unsigned char *data_in,
const size_t in_len,
unsigned char *sign_out,
uint16_t *sign_len)
{
int ret;
ret = hardware_sign_l(config, data_in, in_len, sign_out, sign_len);
Close_Device();
@ -91,20 +97,17 @@ int Hardware_sign(SM2Config * config,const unsigned char * data_in,const size_t
#endif
void ThreadSign(HWsign * HW_ptr){
void
ThreadSign(HWsign *HW_ptr)
{
uint8_t sha[128];
cpu_set_t mask;
CPU_ZERO(&mask);
CPU_SET(HW_ptr->cpu_core, &mask);
if(pthread_setaffinity_np(pthread_self(),sizeof(mask),&mask)<0){
ERROL("Sign Thread start fail");
}
while (1)
{
if (pthread_setaffinity_np(pthread_self(), sizeof(mask), &mask) < 0) { ERROL("Sign Thread start fail"); }
while (1) {
std::unique_lock<std::mutex> lock(HW_ptr->sign_mtx);
while (HW_ptr->I_seq!=-2)
{
while (HW_ptr->I_seq != -2) {
if (HW_ptr->thread_exit) {
NOTICEL("sign thread release\n");
sleep(0);
@ -121,7 +124,8 @@ void ThreadSign(HWsign * HW_ptr){
NOTICEL("sign cpu:%d\n", sched_getcpu());
sm3_update(HW_ptr->sm3_hd, (uint8_t *) HW_ptr->buff->data(), HW_ptr->buff->size());
sm3_final(HW_ptr->sm3_hd, sha);
do_sm2_sign((char*)HW_ptr->sm2_hd->prikey,(char*)HW_ptr->sm2_hd->pubkey,(char *) sha, 32, (char *)HW_ptr->sign);
do_sm2_sign((char *) HW_ptr->sm2_hd->prikey, (char *) HW_ptr->sm2_hd->pubkey, (char *) sha, 32,
(char *) HW_ptr->sign);
// Hardware_sign(Handle->sm2_hd,(const unsigned char *)(buf+offset),len-offset,sign,&sign_len);
HW_ptr->ver_set.sign_len = 64;
memcpy(HW_ptr->ver_set.sign, HW_ptr->sign, 64);
@ -132,7 +136,6 @@ void ThreadSign(HWsign * HW_ptr){
DEBUGL("\n&&&&&&&& sign: sign &&&&&&&&&&&&&&&&&&&&&&&&");
print_data2((char *) HW_ptr->sign, 64, 64);
// HW_ptr->sign_finish.notify_all();
}
}
@ -158,49 +161,52 @@ void ThreadSign(HWsign * HW_ptr){
// }
void GenSEI(HWsign * HW_ptr,const char * sei_head, const uint16_t sei_len,void * param){
void
GenSEI(HWsign *HW_ptr, const char *sei_head, const uint16_t sei_len, void *param)
{
uint8_t sei[2048], sei_race[1024];
uint16_t sign_len = 64;
uint8_t *set_ptr = sei;
uint32_t rtp_len;
memcpy(set_ptr, sei_head, sei_len);
set_ptr += sei_len;
set_ptr=SecMedia::appendSEIframe(set_ptr,SEC_SET_PT,(uint8_t*)SecMedia::Sec_set_UUID,(uint8_t*)&HW_ptr->sec_set,sizeof(HW_ptr->sec_set));
set_ptr=SecMedia::appendSEIframe(set_ptr,VER_SET_PT,(uint8_t*)SecMedia::Ver_set_UUID,(uint8_t*)&HW_ptr->ver_set,sizeof(HW_ptr->ver_set));
set_ptr = SecMedia::appendSEIframe(
set_ptr, SEC_SET_PT, (uint8_t *) SecMedia::Sec_set_UUID, (uint8_t *) &HW_ptr->sec_set, sizeof(HW_ptr->sec_set));
set_ptr = SecMedia::appendSEIframe(
set_ptr, VER_SET_PT, (uint8_t *) SecMedia::Ver_set_UUID, (uint8_t *) &HW_ptr->ver_set, sizeof(HW_ptr->ver_set));
HW_ptr->sei_param = nullptr;
rtp_len = set_ptr - sei;
SUCSL("success sign!!!!!!!!!! sei package\n");
// send_rtp(HW_ptr,(char *) sei_head,sei_len,0,param);
send_rtp(HW_ptr, (char *) sei, rtp_len, 0, param);
}
bool MakeFU(uint8_t in, FU &fu) {
bool
MakeFU(uint8_t in, FU &fu)
{
fu.S = in >> 7;
fu.E = (in >> 6) & 0x01;
fu.R = (in >> 5) & 0x01;
fu.type = in & 0x1f;
if (fu.R != 0) {
return false;
}
if (fu.R != 0) { return false; }
return true;
}
void Make265FU(uint8_t in, FU &fu) {
void
Make265FU(uint8_t in, FU &fu)
{
fu.S = in >> 7;
fu.E = (in >> 6) & 0x01;
fu.type = in & 0x3f;
}
uint32_t add_racing_code(uint8_t *dst,uint8_t *src, uint32_t src_len,uint16_t jump_bytes)
uint32_t
add_racing_code(uint8_t *dst, uint8_t *src, uint32_t src_len, uint16_t jump_bytes)
{
const uint8_t d_zero[] = {0x00, 0x00};
uint8_t *ptr_zero = src + jump_bytes, *dst_head = dst, *src_tail = src + src_len, *noncpy_src_head = src;
uint32_t data_len = 0, remain_data_len = src_len - jump_bytes;
while(remain_data_len>2)
{
while (remain_data_len > 2) {
ptr_zero = (uint8_t *) memmem(ptr_zero, remain_data_len - 2, &d_zero, sizeof(d_zero));
if (ptr_zero) {//0x00 1 2 3
ptr_zero += 2;
@ -213,29 +219,28 @@ uint32_t add_racing_code(uint8_t *dst,uint8_t *src, uint32_t src_len,uint16_t j
noncpy_src_head = ptr_zero;//更新未复制的源数据头
}
remain_data_len = (src_tail - ptr_zero);
}else
{
} else {
break;
}
}
data_len = src_tail - noncpy_src_head;
memcpy(dst_head, noncpy_src_head, data_len);
//int finnum=(int)(dst_head-dst)+(int)data_len;
return (uint32_t)(dst_head-dst)+data_len;;
return (uint32_t) (dst_head - dst) + data_len;
;
}
uint32_t del_racing_code(uint8_t *dst,uint8_t *src, uint32_t src_len)
uint32_t
del_racing_code(uint8_t *dst, uint8_t *src, uint32_t src_len)
{
const uint8_t d_zero[] = {0x00, 0x00, 0x03};
uint8_t *ptr_zero = src, *dst_head = dst, *src_tail = src + src_len, *noncpy_src_head = src;
uint32_t data_len = 0, remain_data_len = src_len;
while(remain_data_len>2)
{
while (remain_data_len > 2) {
ptr_zero = (uint8_t *) memmem(ptr_zero, remain_data_len - 2, &d_zero, sizeof(d_zero));
if (ptr_zero) {//0x00 1 2 3
ptr_zero += 3;
data_len = ptr_zero - noncpy_src_head - 1;//末尾0x03 不要
memcpy(dst_head, noncpy_src_head, data_len);
dst_head += data_len;
@ -243,20 +248,21 @@ uint32_t del_racing_code(uint8_t *dst,uint8_t *src, uint32_t src_len)
noncpy_src_head = ptr_zero;//更新未复制的源数据头
remain_data_len = (src_tail - ptr_zero);
}else
{
} else {
break;
}
}
data_len = src_tail - noncpy_src_head;
memcpy(dst_head, noncpy_src_head, data_len);
//int finnum=(int)(dst_head-dst)+(int)data_len;
return (uint32_t)(dst_head-dst)+data_len;;
return (uint32_t) (dst_head - dst) + data_len;
;
}
// void * HWSign_init(const function<void(const char * rtp_ptr, const uint32_t rtp_len)> rtp_callback){
void * HWSign_init(struct sec_set_info * sign_info){
void *
HWSign_init(struct sec_set_info *sign_info)
{
if (!sign_info) return nullptr;
HWsign *HWSign_hd = new HWsign();
HWSign_hd->I_seq = -1;
@ -273,12 +279,10 @@ void * HWSign_init(struct sec_set_info * sign_info){
HWSign_hd->buff_que = new ThreadsafeQueue<pair<shared_ptr<string>, void *>>();
// HWSign_hd->rtp_cb=rtp_callback;
HWSign_hd->rtp_cb = [HWSign_hd](const char *rtp_ptr, const uint32_t rtp_len, void *param) {
DEBUGL("\n========================= output ====== ");
// print_rtp2(rtp_ptr,rtp_len,12);
auto str_ptr = make_shared<string>(rtp_ptr, rtp_len);
HWSign_hd->buff_que->push(make_pair(str_ptr, param));
};
sm3_init(HWSign_hd->sm3_hd);
// SM2Config sm2fig={
@ -307,7 +311,9 @@ void * HWSign_init(struct sec_set_info * sign_info){
return (void *) HWSign_hd;
}
void HWSign_release(void* Handle){
void
HWSign_release(void *Handle)
{
HWsign *HWSign_hd = (HWsign *) Handle;
delete HWSign_hd->sm3_hd;
delete HWSign_hd->sm2_hd;
@ -319,7 +325,9 @@ void HWSign_release(void* Handle){
HWSign_hd->rtp_cb = nullptr;
}
uint16_t get_sequence(const char * rtp ,int tcp){
uint16_t
get_sequence(const char *rtp, int tcp)
{
uint16_t seq;
if (tcp) {
memcpy(&seq, rtp + 2 + 4, 2);
@ -329,19 +337,19 @@ uint16_t get_sequence(const char * rtp ,int tcp){
return htons(seq);
}
void send_rtp(HWsign* Handle,const char * buf, const uint32_t len ,int tcp,void * param){
void
send_rtp(HWsign *Handle, const char *buf, const uint32_t len, int tcp, void *param)
{
char *send_buff = (char *) malloc(len);
uint8_t offset, offset2;
uint16_t seq;
memcpy(send_buff, buf, len);
if (tcp)
{
if (tcp) {
offset2 = 16;
offset = 4;
send_buff[2] = (len - 4) >> 8;
send_buff[3] = (len - 4) & 0x00FF;
}else
{
} else {
offset2 = 12;
offset = 0;
}
@ -356,7 +364,17 @@ void send_rtp(HWsign* Handle,const char * buf, const uint32_t len ,int tcp,void
Handle->rtp_cb(send_buff, len, param);
free(send_buff);
}
void sign_data(HWsign* Handle,const char * buf, const uint32_t len,uint8_t offset,int tcp,void * param,const char * sei_head, const uint16_t sei_len){
void
sign_data(HWsign *Handle,
const char *buf,
const uint32_t len,
uint8_t offset,
int tcp,
void *param,
const char *sei_head,
const uint16_t sei_len)
{
uint8_t sha[128], sign[128], sei[2048], sei_race[1024];
uint16_t sign_len = 64;
sm3_update(Handle->sm3_hd, (uint8_t *) buf + offset, len - offset);
@ -371,7 +389,8 @@ void sign_data(HWsign* Handle,const char * buf, const uint32_t len,uint8_t offse
print_data2((char *) sign, 64, 64);
Handle->sei_param = nullptr;
auto rtp_len=SecMedia::GeneHWSecritySEI(sei,Handle->track_type,1,len-offset,sign_len,sign,(char *)sei_head,sei_len);
auto rtp_len = SecMedia::GeneHWSecritySEI(
sei, Handle->track_type, 1, len - offset, sign_len, sign, (char *) sei_head, sei_len);
rtp_len = add_racing_code(sei_race, sei + sei_len, rtp_len - sei_len);
memcpy(sei + sei_len, sei_race, rtp_len);
rtp_len += sei_len;
@ -379,6 +398,7 @@ void sign_data(HWsign* Handle,const char * buf, const uint32_t len,uint8_t offse
send_rtp(Handle, (char *) sei, rtp_len, tcp, param);
// Handle->seq_accu++;
}
// void none_sign_data(HWsign* Handle,uint8_t offset,int tcp,void * param,const char * sei_head){
// uint8_t sei[1024];
// auto rtp_len=SecMedia::GeneHWSecritySEI(sei,Handle->track_type,0,0,64,nullptr,(char *)sei_head, Handle->sei_len);
@ -386,7 +406,9 @@ void sign_data(HWsign* Handle,const char * buf, const uint32_t len,uint8_t offse
// WRNGL("Warning!!!!!!!!!! none sei package\n");
// send_rtp(Handle,(char *) sei,rtp_len,tcp,param);
// }
int HWSign_rtp_out(void* Handle, char * buf, uint32_t * len, void ** param){
int
HWSign_rtp_out(void *Handle, char *buf, uint32_t *len, void **param)
{
HWsign *HWSign_hd = (HWsign *) Handle;
if (!HWSign_hd) return -1;
// if (HWSign_hd->buff_que->empty()) return -1;
@ -401,7 +423,9 @@ int HWSign_rtp_out(void* Handle, char * buf, uint32_t * len, void ** param){
return 1;
}
void flush_all(HWsign* HWSign_hd){
void
flush_all(HWsign *HWSign_hd)
{
auto rtp_list = *(HWSign_hd->rtp_buff);
for (auto &rtp_sig : rtp_list) {
HWSign_hd->rtp_cb(rtp_sig.first->data(), rtp_sig.first->size(), rtp_sig.second);
@ -412,10 +436,14 @@ void flush_all(HWsign* HWSign_hd){
DEBUGL("flush all!!!!!!!!!! \n");
}
int HWSign_rtp_264(HWsign* HWSign_hd, const char * buf, const uint32_t len,int tcp, void * param){
int
HWSign_rtp_264(HWsign *HWSign_hd, const char *buf, const uint32_t len, int tcp, void *param)
{
uint8_t offset;
if (tcp) offset=16;
else offset=12;
if (tcp)
offset = 16;
else
offset = 12;
const char *rtp = buf + offset;
int length = len - offset;
@ -444,8 +472,7 @@ int HWSign_rtp_264(HWsign* HWSign_hd, const char * buf, const uint32_t len,int t
if (len < 1300) {
std::unique_lock<std::mutex> lock(HWSign_hd->sign_mtx);
if (!HWSign_hd->buff->empty())
{
if (!HWSign_hd->buff->empty()) {
if (HWSign_hd->I_seq == -5)
GenSEI(HWSign_hd, buf, len, param);
else
@ -454,12 +481,9 @@ int HWSign_rtp_264(HWsign* HWSign_hd, const char * buf, const uint32_t len,int t
HWSign_hd->I_seq = -1;
HWSign_hd->buff->clear();
return -1;
}else
{
} else {
WRNGL("Without Sign data\n");
}
}
HWSign_hd->I_seq = -1;
HWSign_hd->rtp_cb(buf, len, param);
@ -469,8 +493,7 @@ int HWSign_rtp_264(HWsign* HWSign_hd, const char * buf, const uint32_t len,int t
FU fu;
MakeFU((uint8_t) rtp[1], fu);
if (fu.type!=5)
{
if (fu.type != 5) {
HWSign_hd->rtp_cb(buf, len, param);
// send_rtp(HWSign_hd,buf,len,tcp,param);
return 1;
@ -510,8 +533,6 @@ int HWSign_rtp_264(HWsign* HWSign_hd, const char * buf, const uint32_t len,int t
HWSign_hd->rtp_cb(buf, len, param);
return 1;
}
}
default: {
HWSign_hd->rtp_cb(buf, len, param);
@ -520,11 +541,14 @@ int HWSign_rtp_264(HWsign* HWSign_hd, const char * buf, const uint32_t len,int t
}
}
int HWSign_rtp_265(HWsign* HWSign_hd, const char * buf, const uint32_t len,int tcp, void * param){
int
HWSign_rtp_265(HWsign *HWSign_hd, const char *buf, const uint32_t len, int tcp, void *param)
{
uint8_t offset;
if (tcp) offset=16;
else offset=12;
if (tcp)
offset = 16;
else
offset = 12;
const char *rtp = buf + offset;
int length = len - offset;
@ -546,12 +570,10 @@ int HWSign_rtp_265(HWsign* HWSign_hd, const char * buf, const uint32_t len,int t
if (len < 1300) {
std::unique_lock<std::mutex> lock(HWSign_hd->sign_mtx);
if (!HWSign_hd->buff->empty())
{
if (!HWSign_hd->buff->empty()) {
if (HWSign_hd->I_seq == -5)
GenSEI(HWSign_hd, buf, len, param);
else
if(HWSign_hd->I_seq==-2)
else if (HWSign_hd->I_seq == -2)
WRNGL("Sign not complete\n");
else
WRNGL("non Sign\n");
@ -559,12 +581,9 @@ int HWSign_rtp_265(HWsign* HWSign_hd, const char * buf, const uint32_t len,int t
HWSign_hd->I_seq = -1;
HWSign_hd->buff->clear();
return -1;
}else
{
} else {
WRNGL("Without Sign data\n");
}
}
HWSign_hd->I_seq = -1;
HWSign_hd->rtp_cb(buf, len, param);
@ -574,8 +593,7 @@ int HWSign_rtp_265(HWsign* HWSign_hd, const char * buf, const uint32_t len,int t
FU fu;
Make265FU((uint8_t) rtp[2], fu);
if (!(fu.type>=H265Nal::NAL_IDR_W_RADL && fu.type<=H265Nal::NAL_IDR_N_LP))
{
if (!(fu.type >= H265Nal::NAL_IDR_W_RADL && fu.type <= H265Nal::NAL_IDR_N_LP)) {
HWSign_hd->rtp_cb(buf, len, param);
// send_rtp(HWSign_hd,buf,len,tcp,param);
return 1;
@ -613,8 +631,6 @@ int HWSign_rtp_265(HWsign* HWSign_hd, const char * buf, const uint32_t len,int t
HWSign_hd->rtp_cb(buf, len, param);
return 1;
}
}
default: {
HWSign_hd->rtp_cb(buf, len, param);
@ -623,10 +639,13 @@ int HWSign_rtp_265(HWsign* HWSign_hd, const char * buf, const uint32_t len,int t
}
}
int HWSign_rtp_input(void* Handle, const char * buf, const uint32_t len, void * param){
int
HWSign_rtp_input(void *Handle, const char *buf, const uint32_t len, void *param)
{
int ret = -1;
HWsign *HWSign_hd = (HWsign *) Handle;
if(!HWSign_hd || !HWSign_hd->rtp_cb || !HWSign_hd->sm3_hd || !HWSign_hd->sm2_hd || !HWSign_hd->buff || !HWSign_hd->buff_que) {
if (!HWSign_hd || !HWSign_hd->rtp_cb || !HWSign_hd->sm3_hd || !HWSign_hd->sm2_hd || !HWSign_hd->buff
|| !HWSign_hd->buff_que) {
throw runtime_error("HWSign_rtp initial error");
return -1;
}
@ -647,22 +666,18 @@ int HWSign_rtp_input(void* Handle, const char * buf, const uint32_t len, void *
return 1;
}
uint8_t payload_type = buf[1] & 0x7f;
switch (payload_type)
{
switch (payload_type) {
case 99://h264
if (HWSign_hd->track_type!=CodecId::CodecH264)
{
if (HWSign_hd->track_type != CodecId::CodecH264) {
HWSign_hd->track_type = CodecId::CodecH264;
DEBUGL("Track type is changed to H.264");
}
ret = HWSign_rtp_264(HWSign_hd, buf, len, 0, param);
break;
case 103 ... 108://h265
if (HWSign_hd->track_type!=CodecId::CodecH265)
{
if (HWSign_hd->track_type != CodecId::CodecH265) {
HWSign_hd->track_type = CodecId::CodecH265;
DEBUGL("Track type is changed to H.265");
}
@ -677,12 +692,12 @@ int HWSign_rtp_input(void* Handle, const char * buf, const uint32_t len, void *
break;
}
return 1;
}
int genSECset(HWsign * HWptr,struct sec_set_info * sign_info){
int
genSECset(HWsign *HWptr, struct sec_set_info *sign_info)
{
uint8_t security_set_version[19] = "Ver 0.0.2";
memset(&HWptr->sec_set, 0, sizeof(HWptr->sec_set));
@ -710,18 +725,24 @@ int genSECset(HWsign * HWptr,struct sec_set_info * sign_info){
memset(&HWptr->ver_set, 0, sizeof(HWptr->ver_set));
HWptr->ver_set.end_flag = 0x80;
return 1;
}
void * HWSign_tcp_init(struct sec_set_info * sign_info){
void *
HWSign_tcp_init(struct sec_set_info *sign_info)
{
HWsec *HWsec_ptr = new HWsec(sign_info);
return (void *) HWsec_ptr;
}
void HWSign_tcp_release(void* Handle){
void
HWSign_tcp_release(void *Handle)
{
delete (HWsec *) Handle;
}
int HWSign_tcp_rtp_input(void* Handle, const char * buf, const uint32_t len, void * param){
int
HWSign_tcp_rtp_input(void *Handle, const char *buf, const uint32_t len, void *param)
{
HWsec *HWsec_ptr = (HWsec *) Handle;
if (!HWsec_ptr || !HWsec_ptr->check_class()) {
@ -732,7 +753,15 @@ int HWSign_tcp_rtp_input(void* Handle, const char * buf, const uint32_t len, voi
HWsec_ptr->HWsec_input((uint8_t *) buf, len, param);
return 1;
}
int HWSign_tcp_rtp_out(void* Handle, char * buf, uint32_t * len,uint16_t* sei_end_offset,uint16_t* append_length, void ** param){
int
HWSign_tcp_rtp_out(void *Handle,
char *buf,
uint32_t *len,
uint16_t *sei_end_offset,
uint16_t *append_length,
void **param)
{
HWsec *HWsec_ptr = (HWsec *) Handle;
if (!HWsec_ptr || !HWsec_ptr->check_class()) {
if (!HWsec_ptr) ERROL("HWSign_tcp_rtp_out NULL Handle");
@ -741,4 +770,3 @@ int HWSign_tcp_rtp_out(void* Handle, char * buf, uint32_t * len,uint16_t* sei_e
}
return HWsec_ptr->HWsec_output(buf, len, sei_end_offset, append_length, param);
}

25
src/HuaWei/HWsign.h
View File

@ -2,8 +2,9 @@
#ifndef _HWSIGN_H
#define _HWSIGN_H
#include<stdlib.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
//#include <functional>
#define API_EXPORT __attribute__((visibility("default")))
@ -16,14 +17,26 @@ struct sec_set_info{
uint8_t prikey[64];
uint8_t pubkey[128];
};
// void * HWSign_init(const std::function<void(const char * rtp_ptr, const uint32_t rtp_len)> rtp_callback);
API_EXPORT int SDF_Device_open();
API_EXPORT int SDF_Device_close();
API_EXPORT void *HK_stream_init(struct sec_set_info *sign_info);
API_EXPORT int HK_stream_in(void *Handle, const char *buf, const uint32_t len, void *param);
API_EXPORT void HK_stream_release(void *Handle);
API_EXPORT int
KH_stream_out(void *Handle, char *buf, uint32_t *len, uint16_t *sei_end_offset, uint16_t *append_length, void **param);
API_EXPORT void *GB28181_stream_init(struct sec_set_info *sign_info);
API_EXPORT int GB28181_stream_in(void *Handle, const char *buf, const uint32_t len, void *param);
API_EXPORT void GB28181_stream_release(void *Handle);
API_EXPORT int GB28181_stream_out(void* Handle, char * buf, uint32_t * len, uint16_t* sei_end_offset,uint16_t* append_length,void ** param);
API_EXPORT int GB28181_stream_out(void *Handle,
char *buf,
uint32_t *len,
uint16_t *sei_end_offset,
uint16_t *append_length,
void **param);
API_EXPORT void *HWSign_init(struct sec_set_info *sign_info);
API_EXPORT void HWSign_release(void *Handle);
@ -33,8 +46,12 @@ API_EXPORT int HWSign_rtp_out(void* Handle, char * buf, uint32_t * len, void **
API_EXPORT void *HWSign_tcp_init(struct sec_set_info *sign_info);
API_EXPORT void HWSign_tcp_release(void *Handle);
API_EXPORT int HWSign_tcp_rtp_input(void *Handle, const char *buf, const uint32_t len, void *param);
API_EXPORT int HWSign_tcp_rtp_out(void* Handle, char * buf, uint32_t * len, uint16_t* sei_end_offset,uint16_t* append_length,void ** param);
API_EXPORT int HWSign_tcp_rtp_out(void *Handle,
char *buf,
uint32_t *len,
uint16_t *sei_end_offset,
uint16_t *append_length,
void **param);
API_EXPORT void *HWVerify_init();
API_EXPORT void HWVerify_release(void *Handle);

47
src/base/event.h Normal file
View File

@ -0,0 +1,47 @@
#ifndef AW_SECURITY_MEDIA_LIB_BASE_EVENT_H
#define AW_SECURITY_MEDIA_LIB_BASE_EVENT_H
#pragma once
#include <atomic>
#include <condition_variable>
#include <mutex>
namespace sign {
class Event {
public:
Event(bool signaled = false) { Reset(signaled); }
bool Signaled() const
{
std::lock_guard<std::mutex> _(_lock);
return _signaled;
}
void Wait()
{
std::unique_lock<std::mutex> _(_lock);
_cv.wait(_, [this] { return _signaled; });
}
void Reset(bool signaled = false)
{
std::lock_guard<std::mutex> _(_lock);
_signaled = signaled;
if (_signaled) { _cv.notify_all(); }
}
void Signal()
{
std::lock_guard<std::mutex> _(_lock);
_signaled = true;
_cv.notify_all();
}
private:
mutable std::mutex _lock;
bool _signaled{false};
std::condition_variable _cv;
};
}// namespace sign
#endif// AW_SECURITY_MEDIA_LIB_BASE_EVENT_H

28
src/base/frame.cpp Normal file
View File

@ -0,0 +1,28 @@
#include "frame.h"
#include "HuaWei/HWcommon.h"
#include <atomic>
namespace sign {
static std::atomic<int> g_frame_cnt{0};
Frame::~Frame() { g_frame_cnt.fetch_sub(1); }
Frame::Ptr
Frame::CreateUDPFrame(const uint8_t *data, size_t len)
{
return std::shared_ptr<Frame>(new Frame(kUDP, data, len));
}
Frame::Ptr
Frame::CreateTCPFrame(const uint8_t *data, size_t len)
{
return std::shared_ptr<Frame>(new Frame(kTCP, data, len));
}
Frame::Frame(Type type, const uint8_t *data, size_t len) : _type(type), _data(data, data + len)
{
auto cur = g_frame_cnt.fetch_add(1);
// INFOL("frame count: %d\n", cur);
}
}// namespace sign

53
src/base/frame.h Normal file
View File

@ -0,0 +1,53 @@
#ifndef AW_SECURITY_MEDIA_LIB_BASE_FRAME_H
#define AW_SECURITY_MEDIA_LIB_BASE_FRAME_H
#pragma once
#include "base/event.h"
#include <memory>
#include <vector>
namespace sign {
class Frame : std::enable_shared_from_this<Frame> {
public:
using Ptr = std::shared_ptr<Frame>;
enum Type { kTCP, kUDP };
static Ptr CreateUDPFrame(const uint8_t *data, size_t len);
static Ptr CreateTCPFrame(const uint8_t *data, size_t len);
public:
~Frame();
Type type() const { return _type; }
const uint8_t *data() const { return _data.data(); }
uint8_t *data() { return _data.data(); }
size_t size() const { return _data.size(); }
// 用户附加的参数
void set_user_data(void *param) { _user_data = param; }
void *user_data() const { return _user_data; }
bool paused() const { return !_event.Signaled(); }
// signaled -> unpaused
void set_paused(bool paused) { _event.Reset(!paused); }
void Wait() { _event.Wait(); }
private:
Frame(Type type, const uint8_t *data, size_t len);
private:
Event _event{true};
Type _type;
std::vector<uint8_t> _data;
void *_user_data;
};
}// namespace sign
#endif// AW_SECURITY_MEDIA_LIB_BASE_FRAME_H

48
src/base/frame_manager.cpp Normal file
View File

@ -0,0 +1,48 @@
#include "frame_manager.h"
#include "HuaWei/HWcommon.h"
namespace sign {
FrameManager::FrameManager() { Init(); }
FrameManager::~FrameManager() {}
bool
FrameManager::Enqueue(Frame::Ptr frame)
{
std::lock_guard<std::mutex> _(_frame_queue_lock);
OnFrameEnqueue(frame);
_frame_queue.push(frame);
return true;
}
Frame::Ptr
FrameManager::Dequeue()
{
Frame::Ptr frame{nullptr};
{
std::lock_guard<std::mutex> _(_frame_queue_lock);
if (_frame_queue.empty()) { return nullptr; }
frame = _frame_queue.front();
_frame_queue.pop();
OnFrameDequeue(frame);
}
frame->Wait();
return frame;
}
void
FrameManager::SetSecSetInfo(sec_set_info *info)
{
_rtp_manager.SetSecSetInfo(info);
}
void
FrameManager::Init()
{
OnFrameEnqueue.connect(&_rtp_manager, &RTPManager::OnFrameEnqueue);
}
}// namespace sign

39
src/base/frame_manager.h Normal file
View File

@ -0,0 +1,39 @@
#ifndef AW_SECURITY_MEDIA_LIB_BASE_FRAME_MANAGER_H
#define AW_SECURITY_MEDIA_LIB_BASE_FRAME_MANAGER_H
#pragma once
#include "HuaWei/HWsign.h"
#include "base/frame.h"
#include "base/rtp_manager.h"
#include "sigslot.h"
#include <mutex>
#include <queue>
namespace sign {
class FrameManager {
public:
sigslot::signal1<Frame::Ptr> OnFrameEnqueue;
sigslot::signal1<Frame::Ptr> OnFrameDequeue;
FrameManager();
~FrameManager();
bool Enqueue(Frame::Ptr frame);
Frame::Ptr Dequeue();
// HACK: 透传参数
void SetSecSetInfo(sec_set_info *info);
private:
void Init();
private:
RTPManager _rtp_manager;
std::mutex _frame_queue_lock;
std::queue<Frame::Ptr> _frame_queue;
};
}// namespace sign
#endif// AW_SECURITY_MEDIA_LIB_BASE_FRAME_MANAGER_H

102
src/base/rtp_decoder.cpp Normal file
View File

@ -0,0 +1,102 @@
#include "rtp_decoder.h"
#include "HuaWei/HWcommon.h"
#include "util.h"
namespace sign {
RTPDecoder::Ptr
RTPDecoder::Create(int payload_type, const char *encoding)
{
auto decoder = std::shared_ptr<RTPDecoder>(new RTPDecoder(payload_type, encoding));
if (decoder->Initialize()) {
return decoder;
} else {
ERROL("RTPDecoder initialize failed. payload_type=%d, encoding=%s\n", payload_type, encoding);
return nullptr;
}
}
RTPDecoder::~RTPDecoder() {}
bool
RTPDecoder::Initialize()
{
_handler = CreateHandler();
_decoder = CreateDecoder(_handler);
return _handler && _decoder;
}
void
RTPDecoder::Input(RTPPacket::Ptr packet)
{
if (packet->packet_size() < 12) {
WRNGL("RTP packet length is too short. len=%lu\n", packet->packet_size());
return;
}
const uint8_t pt = GetRTPPayloadType(packet->packet_data());
if (pt != _payload_type) {
// WRNGL("RTP packet payload type is mismatch. discard it. pt=%d, _payload_type=%d\n", pt, _payload_type);
return;
}
const uint16_t seq = GetRTPSequenceNumber(packet->packet_data());
if (_prev_seq == -1) {
_prev_seq = seq;
} else if (seq != ((_prev_seq + 1) & 0xFFFF)) {
_ref_rtp_packets.clear();
_prev_seq = -1;
return;
} else {
_prev_seq = seq;
}
_ref_rtp_packets.push_back(packet);
auto ret = rtp_payload_decode_input(_decoder.get(), packet->packet_data(), packet->packet_size());
if (ret < 1) { _ref_rtp_packets.pop_back(); }
}
RTPDecoder::RTPDecoder(int payload_type, const char *encoding) : _payload_type(payload_type), _encoding(encoding) {}
std::shared_ptr<rtp_payload_t>
RTPDecoder::CreateHandler()
{
auto handler = std::make_shared<rtp_payload_t>();
handler->alloc = [](void *clazz, int bytes) -> void * {
auto self = (RTPDecoder *) clazz;
auto &buf = self->_buffer;
if (buf.size() < bytes) {
buf.resize(bytes);
} else if (buf.capacity() > 2 * bytes && bytes > 2048) {
buf.shrink_to_fit();
}
return buf.data();
};
handler->free = [](void *clazz, void *packet) {};
handler->packet = [](void *clazz, const void *packet, int bytes, uint32_t timestamp, int flags) {
auto self = (RTPDecoder *) clazz;
int type = 0x1F & ((uint8_t *) packet)[0];
// INFOL("RTPDecoder::CreateHandler packet timestamp=%u, bytes=%d, flags=%d type=%d\n", timestamp, bytes, flags,
// type);
// std::string hex = ToHex((const uint8_t *) packet, bytes);
// INFOL("Data: %s\n", hex.c_str());
DecodedPacket dp{packet, bytes, timestamp, flags};
dp.ref_rtp_packets.swap(self->_ref_rtp_packets);
self->OnDecoded(dp);
};
return handler;
}
std::shared_ptr<void>
RTPDecoder::CreateDecoder(std::shared_ptr<rtp_payload_t> handler)
{
auto rtp_decoder = rtp_payload_decode_create(_payload_type, _encoding.c_str(), handler.get(), this);
return std::shared_ptr<void>(rtp_decoder, rtp_payload_decode_destroy);
}
}// namespace sign

53
src/base/rtp_decoder.h Normal file
View File

@ -0,0 +1,53 @@
#ifndef AW_SECURITY_MEDIA_LIB_BASE_RTP_DECODER_H
#define AW_SECURITY_MEDIA_LIB_BASE_RTP_DECODER_H
#pragma once
#include "rtp-payload.h"
#include "rtp_packet.h"
#include "sigslot.h"
#include <memory>
#include <string>
#include <vector>
namespace sign {
class RTPDecoder {
public:
using Ptr = std::shared_ptr<RTPDecoder>;
// void (*packet)(void* param, const void *packet, int bytes, uint32_t timestamp, int flags);
struct DecodedPacket {
const void *packet;
int bytes;
uint32_t timestamp;
int flags;
std::vector<RTPPacket::Ptr> ref_rtp_packets;
};
sigslot::signal1<DecodedPacket> OnDecoded;
static Ptr Create(int payload_type, const char *encoding = nullptr);
public:
~RTPDecoder();
bool Initialize();
void Input(RTPPacket::Ptr packet);
private:
RTPDecoder(int payload_type, const char *encoding);
std::shared_ptr<rtp_payload_t> CreateHandler();
std::shared_ptr<void> CreateDecoder(std::shared_ptr<rtp_payload_t> handler);
private:
int _payload_type;
std::string _encoding;
int32_t _prev_seq{-1};
std::shared_ptr<void> _decoder;
std::shared_ptr<rtp_payload_t> _handler;
std::vector<uint8_t> _buffer;
std::vector<RTPPacket::Ptr> _ref_rtp_packets;
};
}// namespace sign
#endif// AW_SECURITY_MEDIA_LIB_BASE_RTP_DECODER_H

129
src/base/rtp_manager.cpp Normal file
View File

@ -0,0 +1,129 @@
#include "rtp_manager.h"
#include "HuaWei/HWcommon.h"
#include "base/util.h"
#include <sstream>
namespace sign {
RTPManager::RTPManager() {}
RTPManager::~RTPManager() {}
void
RTPManager::OnFrameEnqueue(Frame::Ptr frame)
{
if (frame->type() == Frame::kTCP) {
ProcessTCPFrame(frame);
} else if (frame->type() == Frame::kUDP) {
ProcessUDPFrame(frame);
} else {
// unknown
}
}
void
RTPManager::SetSecSetInfo(sec_set_info *info)
{}
void
RTPManager::ProcessUDPFrame(Frame::Ptr frame)
{
if (!IsRTPHeader(frame->data(), frame->size())) { return; }
auto packet = RTPPacket::CreateCompleteRTPPacket(this, frame);
ProcessPacket(packet);
}
void
RTPManager::ProcessTCPFrame(Frame::Ptr)
{}
void
RTPManager::ProcessPacket(RTPPacket::Ptr packet)
{
if (!packet->IsComplete()) {
// ERROL("RTP packet is not complete, discard it.\n");
return;
}
MaybeSetSSRC(packet->ssrc());
if (packet->ssrc() != _cur_rtp_ssrc) {
WRNGL("RTP packet ssrc is mismatch. discard it. cur_ssrc=%ld, packet->ssrc=%d\n", _cur_rtp_ssrc,
packet->ssrc());
return;
}
MaybeSetSeq(packet->seq());
if (packet->seq() != _cur_rtp_seq) {
// WRNGL("RTP packet seq is not continuous. cur_seq=%ld, packet->seq=%d\n", _cur_rtp_seq, packet->seq());
SetCurSeq(packet->seq());
}
IncCurSeq();
if (!_decoder) {
_decoder = RTPDecoder::Create(packet->payload_type(), "H264");
if (_decoder) { _decoder->OnDecoded.connect(this, &RTPManager::OnRTPDecoded); }
}
if (_decoder) { _decoder->Input(packet); }
MaybeReplaceSeq(packet);
}
void
RTPManager::SetCurSeq(uint16_t seq)
{
_cur_rtp_seq = seq;
}
void
RTPManager::MaybeSetSSRC(uint32_t ssrc)
{
if (_cur_rtp_ssrc == -1) { SetCurSSRC(ssrc); }
}
void
RTPManager::MaybeSetSeq(uint16_t seq)
{
if (_cur_rtp_seq == -1) { SetCurSeq(seq); }
}
void
RTPManager::MaybeReplaceSeq(RTPPacket::Ptr packet)
{
auto new_seq = (packet->seq() + _insert_packet_num);
packet->set_seq(new_seq);
}
void
RTPManager::SetCurSSRC(uint32_t ssrc)
{
_cur_rtp_ssrc = ssrc;
}
void
RTPManager::IncCurSeq()
{
_cur_rtp_seq = GetNextSeq();
}
uint16_t
RTPManager::GetNextSeq()
{
return (_cur_rtp_seq + 1) & 0xFFFF;
}
void
RTPManager::OnRTPDecoded(RTPDecoder::DecodedPacket packet)
{
uint8_t h264_type = ((uint8_t *) packet.packet)[0] & 0x1F;
// if (h264_type == 1) { return; }
std::stringstream ss;
for (auto &p : packet.ref_rtp_packets) {
ss << p->seq() << " ";
p->set_paused(false);
}
auto str = ss.str();
if (!str.empty()) str.pop_back();
INFOL("RTP decoded. type=%2d, size=%5u seq=[%s]\n", h264_type, packet.bytes, str.c_str());
}
}// namespace sign

65
src/base/rtp_manager.h Normal file
View File

@ -0,0 +1,65 @@
#ifndef AW_SECURITY_MEDIA_LIB_BASE_RTP_MANAGER_H
#define AW_SECURITY_MEDIA_LIB_BASE_RTP_MANAGER_H
#pragma once
#include "HuaWei/HWsign.h"
#include "rtp_decoder.h"
#include "rtp_packet.h"
#include "sigslot.h"
namespace sign {
class RTPManager : public sigslot::has_slots<> {
public:
sigslot::signal1<RTPPacket::Ptr> OnRTPPacket;
public:
RTPManager();
~RTPManager();
void OnFrameEnqueue(Frame::Ptr frame);
// HACK:
void SetSecSetInfo(sec_set_info *info);
private:
void ProcessUDPFrame(Frame::Ptr);
void ProcessTCPFrame(Frame::Ptr);
void ProcessPacket(RTPPacket::Ptr packet);
void SetCurSeq(uint16_t seq);
void MaybeSetSSRC(uint32_t ssrc);
void MaybeSetSeq(uint16_t seq);
void MaybeReplaceSeq(RTPPacket::Ptr packet);
void SetCurSSRC(uint32_t ssrc);
void IncCurSeq();
uint16_t GetNextSeq();
private:
// FOR TEST
void OnRTPDecoded(RTPDecoder::DecodedPacket packet);
private:
/**
* Partical RTP packet -> Complete RTP packet -> Decoder -> Signer
*
* Signer -> RTPManager:
* 1. Modify SEI
* 2. Insert SEI
**/
// 当前不完整的RTP包
RTPPacket::Ptr _cur_rtp_packet{nullptr};
int64_t _cur_rtp_seq{-1};
int64_t _cur_rtp_ssrc{-1};
// 插入的包对seq有影响，需要记录插入包的数量
uint16_t _insert_packet_num{0};
RTPDecoder::Ptr _decoder;
};
}// namespace sign
#endif// AW_SECURITY_MEDIA_LIB_BASE_RTP_MANAGER_H

134
src/base/rtp_packet.cpp Normal file
View File

@ -0,0 +1,134 @@
#include "rtp_packet.h"
#include "HuaWei/HWcommon.h"
#include "util.h"
#include <algorithm>
#include <atomic>
#include <cassert>
namespace sign {
static std::atomic<int> g_rtp_packet_cnt{0};
void
IncRTPPacketCnt()
{
auto cnt = g_rtp_packet_cnt.fetch_add(1);
// INFOL("rtp packet count: %d\n", cnt);
}
void
DecRTPPacketCnt()
{
g_rtp_packet_cnt.fetch_sub(1);
}
RTPPacket::Ptr
RTPPacket::CreateParticalRTPPacket(RTPManager *owner)
{
return std::shared_ptr<RTPPacket>(new RTPPacket(owner));
}
RTPPacket::Ptr
RTPPacket::CreateCompleteRTPPacket(RTPManager *owner, Frame::Ptr udp_frame)
{
return std::shared_ptr<RTPPacket>(new RTPPacket(owner, udp_frame));
}
RTPPacket::~RTPPacket()
{
set_paused(false);
DecRTPPacketCnt();
}
size_t
RTPPacket::packet_size()
{
assert(_frame_type == Frame::kUDP || state() > kMissTCPHeader);
if (_frame_type == Frame::kUDP) {
return _ref_frames.front()->size();
} else {
assert(false);
return 0;
}
}
const uint8_t *
RTPPacket::packet_data() const
{
return _rtp_ptr;
}
uint8_t
RTPPacket::payload_type() const
{
assert(state() > kMissRTPHeader);
return GetRTPPayloadType(_rtp_ptr);
}
uint16_t
RTPPacket::seq() const
{
assert(state() > kMissRTPHeader);
return GetRTPSequenceNumber(_rtp_ptr);
}
uint32_t
RTPPacket::ssrc() const
{
assert(state() > kMissRTPHeader);
return GetRTPSSRC(_rtp_ptr);
}
uint32_t
RTPPacket::timestamp() const
{
assert(state() > kMissRTPHeader);
return GetRTPTimestamp(_rtp_ptr);
}
void
RTPPacket::set_seq(uint16_t seq)
{
if (_frame_type == Frame::kUDP) {
SetRTPSequenceNumber(_rtp_ptr, seq);
} else {
assert(false);
}
}
void
RTPPacket::AddRefFrame(Frame::Ptr frame)
{
assert(false);
}
bool
RTPPacket::paused() const
{
for (auto &frame : _ref_frames) {
if (frame->paused()) { return true; }
}
return false;
}
void
RTPPacket::set_paused(bool paused)
{
std::for_each(_ref_frames.begin(), _ref_frames.end(), [paused](Frame::Ptr &frame) { frame->set_paused(paused); });
}
RTPPacket::RTPPacket(RTPManager *owner, Frame::Ptr udp_frame)
{
IncRTPPacketCnt();
_owner = owner;
_ref_frames.push_back(udp_frame);
_frame_type = Frame::kUDP;
_rtp_ptr = udp_frame->data();
_state = IsRTPHeader(udp_frame->data(), udp_frame->size()) ? kComplete : kError;
udp_frame->set_paused(true);
}
RTPPacket::RTPPacket(RTPManager *owner) : _owner(owner), _frame_type(Frame::kTCP) { IncRTPPacketCnt(); }
}// namespace sign

67
src/base/rtp_packet.h Normal file
View File

@ -0,0 +1,67 @@
#ifndef AW_SECURITY_MEDIA_LIB_BASE_RTP_H
#define AW_SECURITY_MEDIA_LIB_BASE_RTP_H
#pragma once
#include "base/frame.h"
namespace sign {
class RTPManager;
class RTPPacket : std::enable_shared_from_this<RTPPacket> {
public:
enum State {
kError = -1,
kMissTCPHeader = 0,
kMissRTPHeader = 1,
kMissPayload = 2,
kComplete = 3,
};
using Ptr = std::shared_ptr<RTPPacket>;
static Ptr CreateParticalRTPPacket(RTPManager *owner);
static Ptr CreateCompleteRTPPacket(RTPManager *owner, Frame::Ptr udp_frame);
public:
~RTPPacket();
State state() const { return _state; }
bool IsComplete() const { return state() == kComplete; }
// available on kMissRTPHeader,kMissPayload,kComplete
size_t packet_size();
const uint8_t *packet_data() const;
size_t rtp_payload_size();
// rtp header, kMissPayload or kComplete
uint8_t payload_type() const;
uint16_t seq() const;
uint32_t ssrc() const;
uint32_t timestamp() const;
void set_seq(uint16_t seq);
void AddRefFrame(Frame::Ptr frame);
RTPManager *owner() const { return _owner; }
bool paused() const;
void set_paused(bool paused);
private:
RTPPacket(RTPManager *owner, Frame::Ptr udp_frame);
RTPPacket(RTPManager *owner);
private:
RTPManager *_owner{nullptr};
uint8_t *_rtp_ptr{nullptr};
Frame::Type _frame_type;
State _state;
std::vector<Frame::Ptr> _ref_frames;
};
}// namespace sign
#endif// AW_SECURITY_MEDIA_LIB_BASE_RTP_H

1
src/base/signer.cpp Normal file
View File

@ -0,0 +1 @@
#include "signer.h"

15
src/base/signer.h Normal file
View File

@ -0,0 +1,15 @@
#ifndef AW_SECURITY_MEDIA_LIB_BASE_SIGNER_H
#define AW_SECURITY_MEDIA_LIB_BASE_SIGNER_H
#pragma once
#include <mutex>
#include <thread>
namespace sign {
class Signer {
public:
};
}// namespace sign
#endif// AW_SECURITY_MEDIA_LIB_BASE_SIGNER_H

110
src/base/util.cpp Normal file
View File

@ -0,0 +1,110 @@
#include "util.h"
extern "C" {
#include "SVAC/src/sm2sm3/sm2.h"
#include "SVAC/src/sm2sm3/sm3.h"
}
namespace sign {
uint8_t
GetRTPVersion(const uint8_t *data)
{
return (data[0] & 0xC0) >> 6;
}
uint8_t
GetRTPPayloadType(const uint8_t *data)
{
return data[1] & 0x7F;
}
uint16_t
GetRTPSequenceNumber(const uint8_t *data)
{
return (data[2] << 8) | data[3];
}
uint32_t
GetRTPTimestamp(const uint8_t *data)
{
return (data[4] << 24) | (data[5] << 16) | (data[6] << 8) | data[7];
}
uint32_t
GetRTPSSRC(const uint8_t *header)
{
return (header[8] << 24) | (header[9] << 16) | (header[10] << 8) | header[11];
}
void
SetRTPSequenceNumber(uint8_t *header, uint16_t seq)
{
header[2] = seq >> 8;
header[3] = seq & 0xFF;
}
bool
FindRTPOverTCPHeader(const uint8_t *data, size_t len, size_t *header_pos)
{
if (len <= 0) {
return false;
} else if (len == 1) {
if (data[0] == '$') {
*header_pos = 0;
return true;
} else {
return false;
}
} else {
// len >= 2
static const uint8_t kRTPOverTCPHeader[] = {'$', 0};
uint8_t *ptr = (uint8_t *) memmem(data, len, kRTPOverTCPHeader, sizeof(kRTPOverTCPHeader));
if (!ptr) { return false; }
*header_pos = ptr - data;
return true;
}
}
bool
IsRTPHeader(const uint8_t *data, size_t len)
{
if (len < 12) { return false; }
if (GetRTPVersion(data) != 2) { return false; }
return true;
}
bool
IsParticalRTPHeader(const uint8_t *data, size_t len)
{
if (len == 0) {
return true;
} else {
return GetRTPVersion(data) == 2;
}
}
std::string
ToHex(const void *data, size_t len)
{
static const char hex[] = "0123456789ABCDEF";
std::string hex_str;
hex_str.resize(len * 2);
const uint8_t *ptr = (const uint8_t *) data;
for (size_t i = 0; i < len; i++) {
hex_str[2 * i] = hex[ptr[i] >> 4];
hex_str[2 * i + 1] = hex[ptr[i] & 0x0F];
}
return hex_str;
}
std::vector<uint8_t>
SM3Hash(const void *data, size_t len)
{
uint8_t digest[128];
sm3_ctx ctx;
sm3_init(&ctx);
sm3_update(&ctx, (const uint8_t *) data, len);
sm3_final(&ctx, digest);
return std::vector<uint8_t>(digest, digest + 32);
}
}// namespace sign

30
src/base/util.h Normal file
View File

@ -0,0 +1,30 @@
#ifndef AW_SECURITY_MEDIA_LIB_BASE_UTIL_H
#define AW_SECURITY_MEDIA_LIB_BASE_UTIL_H
#pragma once
#include <stdint.h>
#include <string.h>
#include <string>
#include <vector>
namespace sign {
uint8_t GetRTPVersion(const uint8_t *header);
uint8_t GetRTPPayloadType(const uint8_t *header);
uint16_t GetRTPSequenceNumber(const uint8_t *header);
uint32_t GetRTPTimestamp(const uint8_t *header);
uint32_t GetRTPSSRC(const uint8_t *header);
void SetRTPSequenceNumber(uint8_t *header, uint16_t seq);
bool FindRTPOverTCPHeader(const uint8_t *data, size_t len, size_t *header_pos = nullptr);
bool IsRTPHeader(const uint8_t *data, size_t len);
bool IsParticalRTPHeader(const uint8_t *data, size_t len);
std::string ToHex(const void *data, size_t len);
std::vector<uint8_t> SM3Hash(const void *data, size_t len);
}// namespace sign
#endif// AW_SECURITY_MEDIA_LIB_BASE_UTIL_H

1682
src/sigslot.h Normal file
View File

File diff suppressed because it is too large Load Diff