feat parse h264

CMakeLists.txt

@@ -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}/.)

PcapSender/main.cpp

@@ -1,44 +1,46 @@
-#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 <sys/socket.h>
-#include "HuaWei/HWsec.h"
 
 using namespace std;
 using namespace pcpp;
-sec_set_info sign_info={
+sec_set_info sign_info = {
     2,
     "34020000001320000003",
     "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,
+        0xaa, 0xb1, 0x3f, 0xd7, 0x66, 0xe2, 0x75, 0x97, 0xc0, 0x03, 0xe6, 0xe4, 0x1d, 0x77, 0x54, 0x78,
-                0x2f,0x43,0xe4,0xee,0xc8,0x7d,0xc0,0xfb,0xa4,0xb8,0x7d,0x4b,0x8a,0x69,0x7c,0x4e
+        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,
-                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,
+void *
-                0xfc,0x00,0x08,0x97,0x78,0x2c,0x71,0x6b,0xe1,0x26,0xf5,0x1e,0xba,0x31,0xf5,0xb2,
+EncrypInit()
-            }
+{
-        };
-void * EncrypInit(){
     // auto Verify_handle=HWVerify_init();
 
-    auto sign_handle=GB28181_stream_init(&sign_info);  //HWSign_init(&sign_info);
+    auto sign_handle = GB28181_stream_init(&sign_info);//HWSign_init(&sign_info);
     return sign_handle;
 }
-std::string getProtocolTypeAsString(pcpp::ProtocolType protocolType)
+
+std::string
+getProtocolTypeAsString(pcpp::ProtocolType protocolType)
 {
-    switch (protocolType)
+    switch (protocolType) {
-    {
     case pcpp::Ethernet:
         return "Ethernet";
     case pcpp::IPv4:
@@ -53,113 +55,129 @@ 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);
+    select(0, NULL, NULL, NULL, &delta);
 }
-template<typename T,typename U>
+
-timespec TimeDiff(T && minu,U && sub){
+template<typename T, typename U>
+timespec
+TimeDiff(T &&minu, U &&sub)
+{
     timespec deltatime;
-    deltatime.tv_nsec=minu.tv_nsec-sub.tv_nsec;
+    deltatime.tv_nsec = minu.tv_nsec - sub.tv_nsec;
-    deltatime.tv_sec=minu.tv_sec-sub.tv_sec;
+    deltatime.tv_sec = minu.tv_sec - sub.tv_sec;
-    if(deltatime.tv_nsec<0 && deltatime.tv_sec>0){
+    if (deltatime.tv_nsec < 0 && deltatime.tv_sec > 0) {
-        deltatime.tv_nsec+=1000000000;
+        deltatime.tv_nsec += 1000000000;
         deltatime.tv_sec--;
     }
     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);
+    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;
     }
 
-    uint8_t * payload;
+    uint8_t *payload;
     size_t payload_len;
     pcpp::RawPacket rawPacket;
-    bool first_flag=true;
+    bool first_flag = true;
-    timespec nowtime,gaptime;
+    timespec nowtime, gaptime;
     timespec real_now;
-    timespec inital_time,current_time;
+    timespec inital_time, current_time;
     static char sign_out_buf[3096];
     unsigned int sign_out_len;
-    void *param=nullptr;
+    void *param = nullptr;
-    uint16_t offset_len,append_len;
+    uint16_t offset_len, append_len;
-    while (reader->getNextPacket(rawPacket))
+    std::shared_ptr<std::thread> output_thread;
-    {
+    std::atomic<bool> processing{true};
-        pcpp::Packet parsedPacket(&rawPacket,OsiModelTransportLayer);
+    std::atomic<int> processing_cnt{0};
-        auto layer = parsedPacket.getLayerOfType<UdpLayer>(false);
+    if (sign_handle) {
-    
+        output_thread = std::shared_ptr<std::thread>(new std::thread([&] {
-        if(layer){
+            while (processing.load(std::memory_order_relaxed)) {
-            payload=layer->getLayerPayload();
+                int ret =
-            payload_len=layer->getLayerPayloadSize();
+                    GB28181_stream_out(sign_handle, sign_out_buf, &sign_out_len, &offset_len, &append_len, &param);
-            // cout<<" payload_len:" << payload_len<<endl;
+                if (ret != 1) { continue; }
-            nowtime=rawPacket.getPacketTimeStamp();
+                processing_cnt.fetch_sub(1);
-            clock_gettime(CLOCK_MONOTONIC, &real_now);
+                if (append_len == 0) {
-            if(first_flag){
+                    sendto(socket, sign_out_buf, sign_out_len, 0, (const sockaddr *) &addr, sizeof(addr));
-                first_flag=false;
+                } else {
-                inital_time=TimeDiff(nowtime,real_now);
+                    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,
-            current_time.tv_sec=inital_time.tv_sec+real_now.tv_sec;
+                           sizeof(addr));
-            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)
-            {
-                nanosleep(&gaptime,NULL);
-            }else{
-                // cout<<" s:" << gaptime.tv_sec<<" ns:" << gaptime.tv_nsec <<endl;
-            }
-            // ///////////////calculate send time//////////////////
-            if(sign_handle){
-                
-                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);
+            }
+        }));
+    }
 
+    while (reader->getNextPacket(rawPacket)) {
+        pcpp::Packet parsedPacket(&rawPacket, OsiModelTransportLayer);
+        auto layer = parsedPacket.getLayerOfType<UdpLayer>(false);
 
-                
+        if (layer) {
-            }else{
+            payload = layer->getLayerPayload();
-                if(sendto(socket,payload,payload_len,0,(const sockaddr*)&addr,sizeof(addr))==-1){
+            payload_len = layer->getLayerPayloadSize();
+            // cout<<" payload_len:" << payload_len<<endl;
+            nowtime = rawPacket.getPacketTimeStamp();
+            clock_gettime(CLOCK_MONOTONIC, &real_now);
+            if (first_flag) {
+                first_flag = false;
+                inital_time = TimeDiff(nowtime, real_now);
+            }
+            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) {
+                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);
+            } 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,44 +193,43 @@ 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]);
         string filter(argv[4]);
-		printf("filename:%s\nip:%s\nport:%d\nfilter:%s\n", filename.data(), ip,port,filter.data());
+        printf("filename:%s\nip:%s\nport:%d\nfilter:%s\n", filename.data(), ip, port, filter.data());
 
-        sockfd = socket(AF_INET, SOCK_DGRAM , IPPROTO_UDP);//SOCK_STREAM
+        sockfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);//SOCK_STREAM
         if (sockfd == -1) {
             printf("create socket failed : %s\n", strerror(errno));
             return -1;
         }
         int rcvBufSize = 2097152;
         int rcvlen = sizeof(rcvBufSize);
-        setsockopt(sockfd, SOL_SOCKET, SO_SNDBUF, (char*)&rcvBufSize, 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)
+            if (rcvBufSize < 4194304) { printf("socket send buff too small, please set up to 2097152(2M)"); }
-            {
+        } else {
-                printf("socket send buff too small, please set up to 2097152(2M)");
-            }
-        }else {
             printf("socket failed : %s\n", strerror(errno));
             return -1;
         }
         struct sockaddr_in addr;
         addr.sin_family = AF_INET;
         addr.sin_port = htons(port);
-        addr.sin_addr.s_addr =inet_addr(ip);
+        addr.sin_addr.s_addr = inet_addr(ip);
         // if(connect(sockfd, (struct sockaddr*)&addr, sizeof(addr))==-1){
         //     printf("connection error : %s\n", strerror(errno));
         //     return -1;
@@ -221,18 +238,15 @@ int main(int argc, char *argv[]){
         // while (1)
         // {
         cout.flush();
-            auto sign_h=EncrypInit();
+        auto sign_h = EncrypInit();
 
-            ReadPcapAndSend(sockfd,addr,filename,filter,sign_h);
+        ReadPcapAndSend(sockfd, addr, filename, filter, sign_h);
         // }
 
-	}
+    } else {
-	else
-	{
         printf("CMD as: filename.pcap ip port\n");
         system("pause");
         return 0;
     }
     return 0;
-    
 }

src/HuaWei/HWsign.h

@@ -2,41 +2,58 @@
 #ifndef _HWSIGN_H
 #define _HWSIGN_H
 
-#include<stdlib.h> 
+#include <stdint.h>
-#include<stdio.h>
+#include <stdio.h>
+#include <stdlib.h>
 //#include <functional>
 #define API_EXPORT __attribute__((visibility("default")))
 
-struct sec_set_info{
+struct sec_set_info {
     uint8_t cpu_core;
     uint8_t camera_id[21];
-    uint8_t vkek_version[32];           // 秘钥的加密秘钥的版本号
+    uint8_t vkek_version[32];// 秘钥的加密秘钥的版本号
     uint8_t prikey_size;
     uint8_t pubkey_size;
     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 * GB28181_stream_init(struct sec_set_info * sign_info);
+API_EXPORT void *HK_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 int HK_stream_in(void *Handle, const char *buf, const uint32_t len, void *param);
-API_EXPORT void GB28181_stream_release(void* Handle);
+API_EXPORT void HK_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
+KH_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 *GB28181_stream_init(struct sec_set_info *sign_info);
-API_EXPORT void HWSign_release(void* Handle);
+API_EXPORT int GB28181_stream_in(void *Handle, const char *buf, const uint32_t len, void *param);
-API_EXPORT int HWSign_rtp_input(void* Handle, const char * buf, const uint32_t len, void * param);
+API_EXPORT void GB28181_stream_release(void *Handle);
-API_EXPORT int HWSign_rtp_out(void* Handle, char * buf,  uint32_t * len, 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_tcp_init(struct sec_set_info * sign_info);
+API_EXPORT void *HWSign_init(struct sec_set_info *sign_info);
-API_EXPORT void HWSign_tcp_release(void* Handle);
+API_EXPORT void HWSign_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_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_rtp_out(void *Handle, char *buf, uint32_t *len, void **param);
 
+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 void * HWVerify_init();
+API_EXPORT void *HWVerify_init();
-API_EXPORT void HWVerify_release(void* Handle);
+API_EXPORT void HWVerify_release(void *Handle);
-API_EXPORT int HWVerify_rtp_input(void* Handle, const char * buf, const uint32_t len,int tcp, void * param);
+API_EXPORT int HWVerify_rtp_input(void *Handle, const char *buf, const uint32_t len, int tcp, void *param);
 #endif /* _DECRYPT_H */

src/base/event.h

@@ -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

src/base/frame.cpp

@@ -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

src/base/frame.h

@@ -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

src/base/frame_manager.cpp

@@ -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

src/base/frame_manager.h

@@ -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

src/base/rtp_decoder.cpp

@@ -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

src/base/rtp_decoder.h

@@ -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

src/base/rtp_manager.cpp

@@ -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

src/base/rtp_manager.h

@@ -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

src/base/rtp_packet.cpp

@@ -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

src/base/rtp_packet.h

@@ -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

src/base/signer.cpp

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

src/base/signer.h

@@ -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

src/base/util.cpp

@@ -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

src/base/util.h

@@ -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