1
0
mirror of https://github.com/rofafor/vdr-plugin-satip.git synced 2023-10-10 13:37:42 +02:00

Implemented a preliminary state machine for tuner.

This commit is contained in:
Rolf Ahrenberg 2014-11-15 20:15:00 +02:00
parent ede0294943
commit 0bf841555b
4 changed files with 140 additions and 85 deletions

View File

@ -82,3 +82,4 @@ VDR Plugin 'satip' Revision History
- Fixed EIT scan (Thanks to Stefan Schallenberg). - Fixed EIT scan (Thanks to Stefan Schallenberg).
- Refactored input thread to increase performance. - Refactored input thread to increase performance.
- Added new STAT command into the SVDRP interface. - Added new STAT command into the SVDRP interface.
- Refactored tuner implementation.

7
rtsp.c
View File

@ -250,16 +250,17 @@ bool cSatipRtsp::Teardown(const char *uriP)
bool cSatipRtsp::ValidateLatestResponse(void) bool cSatipRtsp::ValidateLatestResponse(void)
{ {
debug("cSatipRtsp::%s(%d)", __FUNCTION__, tunerIdM); bool result = false;
if (handleM) { if (handleM) {
long rc = 0; long rc = 0;
CURLcode res = CURLE_OK; CURLcode res = CURLE_OK;
SATIP_CURL_EASY_GETINFO(handleM, CURLINFO_RESPONSE_CODE, &rc); SATIP_CURL_EASY_GETINFO(handleM, CURLINFO_RESPONSE_CODE, &rc);
if (rc == 200) if (rc == 200)
return true; result = true;
else if (rc != 0) else if (rc != 0)
error("Tuner detected invalid status code %ld [device %d]", rc, tunerIdM); error("Tuner detected invalid status code %ld [device %d]", rc, tunerIdM);
} }
debug("cSatipRtsp::%s(%d): %s", __FUNCTION__, tunerIdM, result ? "ok" : "failed");
return false; return result;
} }

179
tuner.c
View File

@ -28,9 +28,8 @@ cSatipTuner::cSatipTuner(cSatipDeviceIf &deviceP, unsigned int packetLenP)
statusUpdateM(), statusUpdateM(),
pidUpdateCacheM(), pidUpdateCacheM(),
sessionM(""), sessionM(""),
tunerStatusM(tsIdle),
timeoutM(eMinKeepAliveIntervalMs), timeoutM(eMinKeepAliveIntervalMs),
openedM(false),
tunedM(false),
hasLockM(false), hasLockM(false),
signalStrengthM(-1), signalStrengthM(-1),
signalQualityM(-1), signalQualityM(-1),
@ -64,6 +63,8 @@ cSatipTuner::~cSatipTuner()
{ {
debug("cSatipTuner::%s() [device %d]", __FUNCTION__, deviceIdM); debug("cSatipTuner::%s() [device %d]", __FUNCTION__, deviceIdM);
tunerStatusM = tsIdle;
// Stop thread // Stop thread
sleepM.Signal(); sleepM.Signal();
if (Running()) if (Running())
@ -85,27 +86,66 @@ cSatipTuner::~cSatipTuner()
void cSatipTuner::Action(void) void cSatipTuner::Action(void)
{ {
debug("cSatipTuner::%s(): entering [device %d]", __FUNCTION__, deviceIdM); debug("cSatipTuner::%s(): entering [device %d]", __FUNCTION__, deviceIdM);
cTimeMs timeout(eReConnectTimeoutMs); cTimeMs reconnection(eConnectTimeoutMs);
// Do the thread loop // Do the thread loop
while (Running()) { while (Running()) {
// Update pids switch (tunerStatusM) {
UpdatePids(); case tsIdle:
// Remember the heart beat //debug("cSatipTuner::%s(): tsIdle [device %d]", __FUNCTION__, deviceIdM);
KeepAlive(); break;
case tsRelease:
//debug("cSatipTuner::%s(): tsRelease [device %d]", __FUNCTION__, deviceIdM);
Disconnect();
tunerStatusM = tsIdle;
break;
case tsSet:
//debug("cSatipTuner::%s(): tsSet [device %d]", __FUNCTION__, deviceIdM);
reconnection.Set(eConnectTimeoutMs);
Disconnect();
if (Connect()) {
tunerStatusM = tsTuned;
UpdatePids(true);
}
else
tunerStatusM = tsIdle;
break;
case tsTuned:
//debug("cSatipTuner::%s(): tsTuned [device %d]", __FUNCTION__, deviceIdM);
reconnection.Set(eConnectTimeoutMs);
// Read reception statistics via DESCRIBE and RTCP // Read reception statistics via DESCRIBE and RTCP
if (ReadReceptionStatus()) { if (hasLockM || ReadReceptionStatus()) {
// Quirk for devices without valid reception data // Quirk for devices without valid reception data
if (currentServerM && currentServerM->Quirk(cSatipServer::eSatipQuirkForceLock)) { if (currentServerM && currentServerM->Quirk(cSatipServer::eSatipQuirkForceLock)) {
hasLockM = true; hasLockM = true;
signalStrengthM = eDefaultSignalStrength; signalStrengthM = eDefaultSignalStrength;
signalQualityM = eDefaultSignalQuality; signalQualityM = eDefaultSignalQuality;
} }
if (hasLockM)
tunerStatusM = tsLocked;
} }
// Reconnect if necessary break;
if (openedM && timeout.TimedOut()) { case tsLocked:
Disconnect(); //debug("cSatipTuner::%s(): tsLocked [device %d]", __FUNCTION__, deviceIdM);
Connect(); tunerStatusM = tsLocked;
timeout.Set(eReConnectTimeoutMs); if (!UpdatePids()) {
debug("cSatipTuner::%s(): pid update failed - re-tuning [device %d]", __FUNCTION__, deviceIdM);
tunerStatusM = tsSet;
break;
}
if (!KeepAlive()) {
debug("cSatipTuner::%s(): keep-alive failed - re-tuning [device %d]", __FUNCTION__, deviceIdM);
tunerStatusM = tsSet;
break;
}
if (reconnection.TimedOut()) {
debug("cSatipTuner::%s(): connection timeout - re-tuning [device %d]", __FUNCTION__, deviceIdM);
tunerStatusM = tsSet;
break;
}
break;
default:
error("Unknown tuner status %d", tunerStatusM);
break;
} }
sleepM.Wait(100); // to avoid busy loop and reduce cpu load sleepM.Wait(100); // to avoid busy loop and reduce cpu load
} }
@ -114,14 +154,18 @@ void cSatipTuner::Action(void)
bool cSatipTuner::Open(void) bool cSatipTuner::Open(void)
{ {
cMutexLock MutexLock(&mutexM);
debug("cSatipTuner::%s() [device %d]", __FUNCTION__, deviceIdM); debug("cSatipTuner::%s() [device %d]", __FUNCTION__, deviceIdM);
return Connect(); tunerStatusM = tsSet;
return true;
} }
bool cSatipTuner::Close(void) bool cSatipTuner::Close(void)
{ {
cMutexLock MutexLock(&mutexM);
debug("cSatipTuner::%s() [device %d]", __FUNCTION__, deviceIdM); debug("cSatipTuner::%s() [device %d]", __FUNCTION__, deviceIdM);
return Disconnect(); tunerStatusM = tsRelease;
return true;
} }
bool cSatipTuner::Connect(void) bool cSatipTuner::Connect(void)
@ -133,38 +177,29 @@ bool cSatipTuner::Connect(void)
cString connectionUri = cString::sprintf("rtsp://%s", *streamAddrM); cString connectionUri = cString::sprintf("rtsp://%s", *streamAddrM);
cString uri = cString::sprintf("%s/?%s", *connectionUri, *streamParamM); cString uri = cString::sprintf("%s/?%s", *connectionUri, *streamParamM);
// Just retune // Just retune
if (tunedM && (streamIdM >= 0)) { if ((tunerStatusM >= tsTuned) && (streamIdM >= 0) && rtpM && rtcpM) {
debug("cSatipTuner::%s(): retune [device %d]", __FUNCTION__, deviceIdM); debug("cSatipTuner::%s(): retune [device %d]", __FUNCTION__, deviceIdM);
keepAliveM.Set(0); KeepAlive(true);
KeepAlive();
// Flush any old content // Flush any old content
rtpM->Flush(); rtpM->Flush();
openedM = rtspM->Setup(*uri, rtpM->Port(), rtcpM->Port()); return rtspM->Setup(*uri, rtpM->Port(), rtcpM->Port());
return openedM;
} }
keepAliveM.Set(timeoutM); keepAliveM.Set(timeoutM);
openedM = rtspM->Options(*connectionUri); if (rtspM->Options(*connectionUri)) {
if (openedM) {
if (nextServerM && nextServerM->Quirk(cSatipServer::eSatipQuirkSessionId)) if (nextServerM && nextServerM->Quirk(cSatipServer::eSatipQuirkSessionId))
rtspM->SetSession(SkipZeroes(*sessionM)); rtspM->SetSession(SkipZeroes(*sessionM));
if (rtspM->Setup(*uri, rtpM->Port(), rtcpM->Port())) { if (rtspM->Setup(*uri, rtpM->Port(), rtcpM->Port())) {
tunedM = true;
UpdatePids(true);
if (nextServerM) { if (nextServerM) {
cSatipDiscover::GetInstance()->UseServer(nextServerM, true); cSatipDiscover::GetInstance()->UseServer(nextServerM, true);
currentServerM = nextServerM; currentServerM = nextServerM;
nextServerM = NULL; nextServerM = NULL;
} }
} }
else return true;
openedM = false; }
} }
return openedM; return false;
}
openedM = false;
return openedM;
} }
bool cSatipTuner::Disconnect(void) bool cSatipTuner::Disconnect(void)
@ -172,10 +207,11 @@ bool cSatipTuner::Disconnect(void)
cMutexLock MutexLock(&mutexM); cMutexLock MutexLock(&mutexM);
debug("cSatipTuner::%s() [device %d]", __FUNCTION__, deviceIdM); debug("cSatipTuner::%s() [device %d]", __FUNCTION__, deviceIdM);
if (openedM && !isempty(*streamAddrM)) { if ((tunerStatusM != tsIdle) && !isempty(*streamAddrM) && (streamIdM >= 0)) {
cString uri = cString::sprintf("rtsp://%s/stream=%d", *streamAddrM, streamIdM); cString uri = cString::sprintf("rtsp://%s/stream=%d", *streamAddrM, streamIdM);
rtspM->Teardown(*uri); rtspM->Teardown(*uri);
} }
tunerStatusM = tsIdle;
// Reset signal parameters // Reset signal parameters
hasLockM = false; hasLockM = false;
@ -184,8 +220,6 @@ bool cSatipTuner::Disconnect(void)
if (currentServerM) if (currentServerM)
cSatipDiscover::GetInstance()->UseServer(currentServerM, false); cSatipDiscover::GetInstance()->UseServer(currentServerM, false);
openedM = false;
tunedM = false;
statusUpdateM.Set(0); statusUpdateM.Set(0);
timeoutM = eMinKeepAliveIntervalMs; timeoutM = eMinKeepAliveIntervalMs;
addPidsM.Clear(); addPidsM.Clear();
@ -272,12 +306,11 @@ bool cSatipTuner::SetSource(cSatipServer *serverP, const char *parameterP, const
// Update stream address and parameter // Update stream address and parameter
streamAddrM = rtspM->RtspUnescapeString(nextServerM->Address()); streamAddrM = rtspM->RtspUnescapeString(nextServerM->Address());
streamParamM = rtspM->RtspUnescapeString(parameterP); streamParamM = rtspM->RtspUnescapeString(parameterP);
// Reconnect tunerStatusM = tsSet;
Connect();
} }
} }
else else
Disconnect(); tunerStatusM = tsRelease;
sleepM.Signal(); sleepM.Signal();
return true; return true;
} }
@ -303,9 +336,9 @@ bool cSatipTuner::SetPid(int pidP, int typeP, bool onP)
bool cSatipTuner::UpdatePids(bool forceP) bool cSatipTuner::UpdatePids(bool forceP)
{ {
cMutexLock MutexLock(&mutexM); //debug("cSatipTuner::%s(%d) tunerStatus=%s [device %d]", __FUNCTION__, forceP, TunerStatusString(tunerStatusM), deviceIdM);
if (((forceP && pidsM.Size()) || (pidUpdateCacheM.TimedOut() && (addPidsM.Size() || delPidsM.Size()))) && if (((forceP && pidsM.Size()) || (pidUpdateCacheM.TimedOut() && (addPidsM.Size() || delPidsM.Size()))) &&
tunedM && !isempty(*streamAddrM) && (streamIdM > 0)) { (tunerStatusM >= tsTuned) && !isempty(*streamAddrM) && (streamIdM > 0)) {
cString uri = cString::sprintf("rtsp://%s/stream=%d", *streamAddrM, streamIdM); cString uri = cString::sprintf("rtsp://%s/stream=%d", *streamAddrM, streamIdM);
bool usedummy = !!(currentServerM && currentServerM->Quirk(cSatipServer::eSatipQuirkPlayPids)); bool usedummy = !!(currentServerM && currentServerM->Quirk(cSatipServer::eSatipQuirkPlayPids));
if (forceP || usedummy) { if (forceP || usedummy) {
@ -329,44 +362,66 @@ bool cSatipTuner::UpdatePids(bool forceP)
uri = cString::sprintf("%s%d%s", *uri, delPidsM[i], (i == (delPidsM.Size() - 1)) ? "" : ","); uri = cString::sprintf("%s%d%s", *uri, delPidsM[i], (i == (delPidsM.Size() - 1)) ? "" : ",");
} }
} }
if (rtspM->Play(*uri)) { if (!rtspM->Play(*uri))
return false;
addPidsM.Clear(); addPidsM.Clear();
delPidsM.Clear(); delPidsM.Clear();
return true;
}
Disconnect();
} }
return false; return true;
} }
bool cSatipTuner::KeepAlive(void) bool cSatipTuner::KeepAlive(bool forceP)
{ {
//debug("cSatipTuner::%s(%d) tunerStatus=%s [device %d]", __FUNCTION__, forceP, TunerStatusString(tunerStatusM), deviceIdM);
cMutexLock MutexLock(&mutexM); cMutexLock MutexLock(&mutexM);
if (tunedM && keepAliveM.TimedOut()) { if (keepAliveM.TimedOut()) {
cString uri = cString::sprintf("rtsp://%s/stream=%d", *streamAddrM, streamIdM);
keepAliveM.Set(timeoutM); keepAliveM.Set(timeoutM);
if (rtspM->Options(*uri)) forceP = true;
}
if (forceP && !isempty(*streamAddrM) && (streamIdM > 0)) {
cString uri = cString::sprintf("rtsp://%s/stream=%d", *streamAddrM, streamIdM);
if (!rtspM->Options(*uri))
return false;
}
return true;
}
bool cSatipTuner::ReadReceptionStatus(bool forceP)
{
//debug("cSatipTuner::%s(%d) tunerStatus=%s [device %d]", __FUNCTION__, forceP, TunerStatusString(tunerStatusM), deviceIdM);
cMutexLock MutexLock(&mutexM);
if (statusUpdateM.TimedOut()) {
statusUpdateM.Set(eStatusUpdateTimeoutMs);
forceP = true;
}
if (forceP && !isempty(*streamAddrM) && (streamIdM > 0)) {
cString uri = cString::sprintf("rtsp://%s/stream=%d", *streamAddrM, streamIdM);
if (rtspM->Describe(*uri))
return true; return true;
Disconnect();
} }
return false; return false;
} }
bool cSatipTuner::ReadReceptionStatus(void) const char *cSatipTuner::TunerStatusString(eTunerStatus statusP)
{ {
cMutexLock MutexLock(&mutexM); switch (statusP) {
if (tunedM && !pidsM.Size() && statusUpdateM.TimedOut() ) { case tsIdle:
cString uri = cString::sprintf("rtsp://%s/stream=%d", *streamAddrM, streamIdM); return "tsIdle";
if (rtspM->Describe(*uri)) { case tsRelease:
statusUpdateM.Set(eStatusUpdateTimeoutMs); return "tsRelease";
return true; case tsSet:
return "tsSet";
case tsLocked:
return "tsLocked";
case tsTuned:
return "tsTuned";
default:
break;
} }
Disconnect(); return "---";
}
return false;
} }
int cSatipTuner::SignalStrength(void) int cSatipTuner::SignalStrength(void)
@ -384,7 +439,7 @@ int cSatipTuner::SignalQuality(void)
bool cSatipTuner::HasLock(void) bool cSatipTuner::HasLock(void)
{ {
//debug("cSatipTuner::%s() [device %d]", __FUNCTION__, deviceIdM); //debug("cSatipTuner::%s() [device %d]", __FUNCTION__, deviceIdM);
return tunedM && hasLockM; return (tunerStatusM >= tsTuned) && hasLockM;
} }
cString cSatipTuner::GetSignalStatus(void) cString cSatipTuner::GetSignalStatus(void)
@ -396,5 +451,5 @@ cString cSatipTuner::GetSignalStatus(void)
cString cSatipTuner::GetInformation(void) cString cSatipTuner::GetInformation(void)
{ {
//debug("cSatipTuner::%s() [device %d]", __FUNCTION__, deviceIdM); //debug("cSatipTuner::%s() [device %d]", __FUNCTION__, deviceIdM);
return tunedM ? cString::sprintf("rtsp://%s/?%s [stream=%d]", *streamAddrM, *streamParamM, streamIdM) : "connection failed"; return (tunerStatusM >= tsTuned) ? cString::sprintf("rtsp://%s/?%s [stream=%d]", *streamAddrM, *streamParamM, streamIdM) : "connection failed";
} }

16
tuner.h
View File

@ -53,11 +53,11 @@ private:
eDefaultSignalStrength = 15, eDefaultSignalStrength = 15,
eDefaultSignalQuality = 224, eDefaultSignalQuality = 224,
eStatusUpdateTimeoutMs = 1000, // in milliseconds eStatusUpdateTimeoutMs = 1000, // in milliseconds
eConnectTimeoutMs = 1500, // in milliseconds
ePidUpdateIntervalMs = 250, // in milliseconds ePidUpdateIntervalMs = 250, // in milliseconds
eReConnectTimeoutMs = 5000, // in milliseconds eConnectTimeoutMs = 5000, // in milliseconds
eMinKeepAliveIntervalMs = 30000 // in milliseconds eMinKeepAliveIntervalMs = 30000 // in milliseconds
}; };
enum eTunerStatus { tsIdle, tsRelease, tsSet, tsTuned, tsLocked };
cCondWait sleepM; cCondWait sleepM;
cSatipDeviceIf* deviceM; cSatipDeviceIf* deviceM;
@ -72,12 +72,10 @@ private:
cMutex mutexM; cMutex mutexM;
cTimeMs keepAliveM; cTimeMs keepAliveM;
cTimeMs statusUpdateM; cTimeMs statusUpdateM;
cTimeMs signalInfoCacheM;
cTimeMs pidUpdateCacheM; cTimeMs pidUpdateCacheM;
cString sessionM; cString sessionM;
eTunerStatus tunerStatusM;
int timeoutM; int timeoutM;
bool openedM;
bool tunedM;
bool hasLockM; bool hasLockM;
int signalStrengthM; int signalStrengthM;
int signalQualityM; int signalQualityM;
@ -88,10 +86,10 @@ private:
bool Connect(void); bool Connect(void);
bool Disconnect(void); bool Disconnect(void);
bool KeepAlive(void); bool KeepAlive(bool forceP = false);
bool ReadReceptionStatus(void); bool ReadReceptionStatus(bool forceP = false);
bool UpdateSignalInfoCache(void);
bool UpdatePids(bool forceP = false); bool UpdatePids(bool forceP = false);
const char *TunerStatusString(eTunerStatus statusP);
protected: protected:
virtual void Action(void); virtual void Action(void);
@ -99,7 +97,7 @@ protected:
public: public:
cSatipTuner(cSatipDeviceIf &deviceP, unsigned int packetLenP); cSatipTuner(cSatipDeviceIf &deviceP, unsigned int packetLenP);
virtual ~cSatipTuner(); virtual ~cSatipTuner();
bool IsTuned(void) const { return tunedM; } bool IsTuned(void) const { return tunerStatusM > tsIdle; }
bool SetSource(cSatipServer *serverP, const char *parameterP, const int indexP); bool SetSource(cSatipServer *serverP, const char *parameterP, const int indexP);
bool SetPid(int pidP, int typeP, bool onP); bool SetPid(int pidP, int typeP, bool onP);
bool Open(void); bool Open(void);