From c7caa54d8d58af6159f2c758ad5d6687d461a333 Mon Sep 17 00:00:00 2001
From: sujinwen <sujinwen@454eff88-639b-444f-9e54-f578c98de674>
Date: 星期二, 25 七月 2017 10:53:23 +0800
Subject: [PATCH]
---
RtspFace/PL_RTSPClient.cpp | 167 +++++++++++++++++++++++++++++++++++++++----------------
1 files changed, 117 insertions(+), 50 deletions(-)
diff --git a/RtspFace/PL_RTSPClient.cpp b/RtspFace/PL_RTSPClient.cpp
index b26b2c1..7bcf9d9 100644
--- a/RtspFace/PL_RTSPClient.cpp
+++ b/RtspFace/PL_RTSPClient.cpp
@@ -1,30 +1,45 @@
#include "PL_RTSPClient.h"
+#include "MaterialBuffer.h"
+#include "logger.h"
#include <pthread.h>
-void rtsp_client_sdp_callback(void* arg, const char* val);
-void rtsp_client_fmtp_callback(void* arg, const char* val);
-void rtsp_client_frame_callback(void* arg, uint8_t* buffer, size_t buffSize);
+struct RtspClientParam
+{
+ std::string sdp;
+ std::string fmtp;
+ uint16_t width;
+ uint16_t height;
+ uint32_t fps;
+ std::string codecName;
+ uint32_t bandwidth;
+};
+
+void rtsp_client_set_param_callback(void* arg, RtspClientParam& param);
+void rtsp_client_frame_callback(void* arg, uint8_t* buffer, size_t buffSize, timeval presentationTime);
void rtsp_client_continue_callback(void* arg);
+// depends: struct PL_RTSPClient_Config;
#include "live555/testProgs/testRTSPClient.hpp"
struct RTSPClient_Internal
{
- PL_RTSPClient* client;
- RTSPConfig rtspConfig;
+ PL_RTSPClient_Config rtspConfig;
pthread_t live_daemon_thid;
char eventLoopWatchVariable;
bool live_daemon_running;
pthread_mutex_t* frame_mutex;
pthread_mutex_t* continue_mutex;
- uint8_t* lastBuffer;
- size_t lastBuffSize;
-
+ MB_Frame lastFrame;
+
+ RtspClientParam lastParam;
+
+ volatile bool killed;
+
RTSPClient_Internal() :
- client(nullptr), rtspConfig(), live_daemon_thid(0),
+ rtspConfig(), live_daemon_thid(0),
eventLoopWatchVariable(0), live_daemon_running(false),
frame_mutex(new pthread_mutex_t), continue_mutex(new pthread_mutex_t),
- lastBuffer(nullptr), lastBuffSize(0)
+ lastFrame(), lastParam(), killed(false)
{
pthread_mutex_init(frame_mutex, NULL);
pthread_mutex_init(continue_mutex, NULL);
@@ -49,9 +64,8 @@
void reset()
{
- client = nullptr;
- rtspConfig.progName = "";
- rtspConfig.rtspURL = "";
+ PL_RTSPClient_Config _rtspConfig;
+ rtspConfig = _rtspConfig;
live_daemon_thid = 0;
eventLoopWatchVariable = 0;
live_daemon_running = false;
@@ -76,21 +90,24 @@
continue_mutex = new pthread_mutex_t;
pthread_mutex_init(continue_mutex, NULL);
- lastBuffer = nullptr;
- lastBuffSize = 0;
+ MB_Frame _lastFrame;
+ lastFrame = _lastFrame;
+
+ RtspClientParam _lastParam;
+ lastParam = _lastParam;
}
};
-void* live_daemon_thd(void* arg)
+static void* live_daemon_thd(void* arg)
{
RTSPClient_Internal* in = (RTSPClient_Internal*)arg;
-
+
TaskScheduler* scheduler = BasicTaskScheduler::createNew();
UsageEnvironment* env = BasicUsageEnvironment::createNew(*scheduler);
usage(*env, in->rtspConfig.progName.c_str());
- openURL(*env, in->client, in->rtspConfig.progName.c_str(), in->rtspConfig.rtspURL.c_str());
+ openURL(*env, in->rtspConfig);
in->live_daemon_running = true;
env->taskScheduler().doEventLoop(&(in->eventLoopWatchVariable));
@@ -117,30 +134,30 @@
if (args == nullptr)
return false;
- const RTSPConfig* config = reinterpret_cast<const RTSPConfig*>(args);
+ const PL_RTSPClient_Config* config = reinterpret_cast<const PL_RTSPClient_Config*>(args);
RTSPClient_Internal* in = (RTSPClient_Internal*)internal;
in->reset();
- in->client = this;
in->rtspConfig = *config;
+ in->rtspConfig.args = this;
int ret = pthread_mutex_lock(in->frame_mutex);
if(ret != 0)
{
- printf("pthread_mutex_lock frame_mutex: %s/n", strerror(ret));
+ LOGP(ERROR, "pthread_mutex_lock frame_mutex: %s/n", strerror(ret));
return false;
}
ret = pthread_mutex_lock(in->continue_mutex);
if(ret != 0)
{
- printf("pthread_mutex_lock continue_mutex: %s/n", strerror(ret));
+ LOGP(ERROR, "pthread_mutex_lock continue_mutex: %s/n", strerror(ret));
return false;
}
ret = pthread_create(&(in->live_daemon_thid), NULL, live_daemon_thd, in);
if(ret != 0)
{
- printf("pthread_create: %s/n", strerror(ret));
+ LOGP(ERROR, "pthread_create: %s/n", strerror(ret));
return false;
}
@@ -152,7 +169,13 @@
RTSPClient_Internal* in = (RTSPClient_Internal*)internal;
in->eventLoopWatchVariable = 1;
+
+ pthread_mutex_unlock(in->continue_mutex);
+ pthread_mutex_unlock(in->frame_mutex);
+
pthread_join(in->live_daemon_thid, NULL);
+
+ in->reset();
}
bool PL_RTSPClient::pay(const PipeMaterial& pm)
@@ -168,65 +191,109 @@
int ret = pthread_mutex_unlock(in->continue_mutex);
if(ret != 0)
{
- printf("pthread_mutex_unlock continue_mutex: %s/n", strerror(ret));
+ LOGP(ERROR, "pthread_mutex_unlock continue_mutex: %s/n", strerror(ret));
+ return false;
+ }
+
+ if (in->killed)
+ {
+ LOGP(WARN, "killed 1");
return false;
}
ret = pthread_mutex_lock(in->frame_mutex);
if(ret != 0)
{
- printf("pthread_mutex_lock: %s/n", strerror(ret));
+ LOGP(ERROR, "pthread_mutex_lock: %s/n", strerror(ret));
return false;
}
-
- pm.buffer = in->lastBuffer;
- pm.buffSize = in->lastBuffSize;
+
+ if (in->killed)
+ {
+ LOGP(WARN, "killed 2");
+ return false;
+ }
+
+ pm.type = PipeMaterial::PMT_FRAME;
+ pm.buffer = &(in->lastFrame);
+ pm.buffSize = 0;
pm.former = this;
return true;
}
-void rtsp_client_sdp_callback(void* arg, const char* val)
+void PL_RTSPClient::kill()
{
- if (arg == nullptr || val == nullptr)
+ RTSPClient_Internal* in = (RTSPClient_Internal*)internal;
+ in->killed = true;
+ pthread_mutex_unlock(in->frame_mutex);
+}
+
+void rtsp_client_set_param_callback(void* arg, RtspClientParam& param)
+{
+ if (arg == nullptr)
return;
PL_RTSPClient* client = (PL_RTSPClient*)arg;
+ RTSPClient_Internal* in = (RTSPClient_Internal*)(client->internal);
+ in->lastParam = param;
if (client->manager == nullptr)
return;
+
+ char tmp[50];
- client->manager->set_global_param(PLGP_RTSP_SDP, val);
+ client->manager->set_param(PLGP_RTSP_SDP, param.sdp);
+ client->manager->set_param(PLGP_RTSP_FMTP, param.fmtp);
+ sprintf(tmp, "%u", param.width); client->manager->set_param(PLGP_RTSP_WIDTH, std::string(tmp));
+ sprintf(tmp, "%u", param.height); client->manager->set_param(PLGP_RTSP_HEIGHT, std::string(tmp));
+ sprintf(tmp, "%u", param.fps); client->manager->set_param(PLGP_RTSP_FPS, std::string(tmp));
+
+ /*
+ std::string fmtp(client->manager->get_param(PLGP_RTSP_FMTP));
+ if (fmtp.empty())
+ return ;
+
+ uint32_t numSPropRecords = 0;
+ SPropRecord *p_record = parseSPropParameterSets(fmtp.c_str(), numSPropRecords);
+ if (numSPropRecords < 2)
+ {
+ LOG_WARN << "numSPropRecords < 2" << std::endl;
+ return ;
+ }
+
+ SPropRecord &sps = p_record[0];
+ SPropRecord &pps = p_record[1];
+
+ LOG_INFO << "sps.sPropLength" << sps.sPropLength << LOG_ENDL;
+ for (int i = 0; i < sps.sPropLength; i++)
+ LOGP(INFO, "0x%02X ", (int)sps.sPropBytes[i]);
+
+ LOG_INFO << "pps.sPropLength" << pps.sPropLength << LOG_ENDL;
+ for (int i = 0; i < pps.sPropLength; i++)
+ LOGP(INFO, "0x%02X ", (int)pps.sPropBytes[i]);
+ */
}
-void rtsp_client_fmtp_callback(void* arg, const char* val)
-{
- if (arg == nullptr || val == nullptr)
- return;
-
- PL_RTSPClient* client = (PL_RTSPClient*)arg;
-
- if (client->manager == nullptr)
- return;
-
- client->manager->set_global_param(PLGP_RTSP_FMTP, val);
-}
-
-void rtsp_client_frame_callback(void* arg, uint8_t* buffer, size_t buffSize)
+void rtsp_client_frame_callback(void* arg, uint8_t* buffer, size_t buffSize, timeval presentationTime)
{
if (arg == nullptr || buffer == nullptr || buffSize == 0)
return;
PL_RTSPClient* client = (PL_RTSPClient*)arg;
RTSPClient_Internal* in = (RTSPClient_Internal*)(client->internal);
-
- in->lastBuffer = buffer;
- in->lastBuffSize = buffSize;
+ in->lastFrame.type = MB_Frame::MBFT_H264_NALU;
+ in->lastFrame.buffer = buffer;
+ in->lastFrame.buffSize = buffSize;
+ in->lastFrame.width = in->lastParam.width;//#todo bug zero0
+ in->lastFrame.height = in->lastParam.height;
+ in->lastFrame.pts = presentationTime;
+
int ret = pthread_mutex_unlock(in->frame_mutex);
if(ret != 0)
{
- printf("pthread_mutex_unlock frame_mutex: %s/n", strerror(ret));
+ LOG_ERROR << "pthread_mutex_unlock frame_mutex: " << strerror(ret) << std::endl;
}
}
@@ -241,6 +308,6 @@
int ret = pthread_mutex_lock(in->continue_mutex);
if(ret != 0)
{
- printf("pthread_mutex_unlock continue_mutex: %s/n", strerror(ret));
+ LOG_ERROR << "pthread_mutex_lock continue_mutex: " << strerror(ret) << std::endl;
}
}
--
Gitblit v1.8.0