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

547 lines
17 KiB
C
Raw Normal View History

2014-03-08 12:07:47 +01:00
/*
* device.c: SAT>IP plugin for the Video Disk Recorder
*
* See the README file for copyright information and how to reach the author.
*
*/
#include <vdr/menu.h> // cRecordControl
2014-03-08 12:07:47 +01:00
#include "config.h"
#include "discover.h"
2014-12-05 22:14:40 +01:00
#include "log.h"
#include "param.h"
2014-03-08 12:07:47 +01:00
#include "device.h"
static cSatipDevice * SatipDevicesS[SATIP_MAX_DEVICES] = { NULL };
cSatipDevice::cSatipDevice(unsigned int indexP)
: deviceIndexM(indexP),
isPacketDeliveredM(false),
isOpenDvrM(false),
deviceNameM(*cString::sprintf("%s %d", *DeviceType(), deviceIndexM)),
2014-03-28 18:53:22 +01:00
channelM(),
createdM(0),
mutexM()
2014-03-08 12:07:47 +01:00
{
unsigned int bufsize = (unsigned int)SATIP_BUFFER_SIZE;
bufsize -= (bufsize % TS_SIZE);
info("Creating device CardIndex=%d DeviceNumber=%d [device %u]", CardIndex(), DeviceNumber(), deviceIndexM);
2014-03-08 12:07:47 +01:00
tsBufferM = new cRingBufferLinear(bufsize + 1, TS_SIZE, false,
2014-12-14 20:39:13 +01:00
*cString::sprintf("SATIP#%d TS", deviceIndexM));
2014-03-08 12:07:47 +01:00
if (tsBufferM) {
2014-12-01 17:12:12 +01:00
tsBufferM->SetTimeouts(10, 10);
2014-03-08 12:07:47 +01:00
tsBufferM->SetIoThrottle();
pTunerM = new cSatipTuner(*this, tsBufferM->Free());
}
// Start section handler
pSectionFilterHandlerM = new cSatipSectionFilterHandler(deviceIndexM, bufsize + 1);
StartSectionHandler();
}
cSatipDevice::~cSatipDevice()
{
2014-12-06 16:02:45 +01:00
debug1("%s [device %u]", __PRETTY_FUNCTION__, deviceIndexM);
2014-03-08 12:07:47 +01:00
// Stop section handler
StopSectionHandler();
DELETE_POINTER(pSectionFilterHandlerM);
DELETE_POINTER(pTunerM);
DELETE_POINTER(tsBufferM);
}
bool cSatipDevice::Initialize(unsigned int deviceCountP)
{
2014-12-07 16:27:53 +01:00
debug1("%s (%u)", __PRETTY_FUNCTION__, deviceCountP);
2014-03-08 12:07:47 +01:00
if (deviceCountP > SATIP_MAX_DEVICES)
deviceCountP = SATIP_MAX_DEVICES;
for (unsigned int i = 0; i < deviceCountP; ++i)
SatipDevicesS[i] = new cSatipDevice(i);
for (unsigned int i = deviceCountP; i < SATIP_MAX_DEVICES; ++i)
SatipDevicesS[i] = NULL;
return true;
}
void cSatipDevice::Shutdown(void)
{
2014-12-06 16:02:45 +01:00
debug1("%s", __PRETTY_FUNCTION__);
2014-03-08 12:07:47 +01:00
for (int i = 0; i < SATIP_MAX_DEVICES; ++i) {
if (SatipDevicesS[i])
SatipDevicesS[i]->CloseDvr();
}
}
unsigned int cSatipDevice::Count(void)
{
unsigned int count = 0;
2014-12-06 16:02:45 +01:00
debug1("%s", __PRETTY_FUNCTION__);
2014-03-08 12:07:47 +01:00
for (unsigned int i = 0; i < SATIP_MAX_DEVICES; ++i) {
if (SatipDevicesS[i] != NULL)
count++;
}
return count;
}
cSatipDevice *cSatipDevice::GetSatipDevice(int cardIndexP)
{
debug16("%s (%d)", __PRETTY_FUNCTION__, cardIndexP);
2014-03-08 12:07:47 +01:00
for (unsigned int i = 0; i < SATIP_MAX_DEVICES; ++i) {
if (SatipDevicesS[i] && (SatipDevicesS[i]->CardIndex() == cardIndexP)) {
debug16("%s (%d): Found!", __PRETTY_FUNCTION__, cardIndexP);
2014-03-08 12:07:47 +01:00
return SatipDevicesS[i];
}
}
return NULL;
}
cString cSatipDevice::GetSatipStatus(void)
{
cString info = "";
for (int i = 0; i < cDevice::NumDevices(); i++) {
const cDevice *device = cDevice::GetDevice(i);
if (device && strstr(device->DeviceType(), "SAT>IP")) {
int timers = 0;
bool live = (device == cDevice::ActualDevice());
bool lock = device->HasLock();
const cChannel *channel = device->GetCurrentlyTunedTransponder();
LOCK_TIMERS_READ;
for (const cTimer *timer = Timers->First(); timer; timer = Timers->Next(timer)) {
if (timer->Recording()) {
cRecordControl *control = cRecordControls::GetRecordControl(timer);
if (control && control->Device() == device)
timers++;
}
}
info = cString::sprintf("%sDevice: %s\n", *info, *device->DeviceName());
if (lock)
info = cString::sprintf("%sCardIndex: %d HasLock: yes Strength: %d Quality: %d%s\n", *info, device->CardIndex(), device->SignalStrength(), device->SignalQuality(), live ? " Live: yes" : "");
else
info = cString::sprintf("%sCardIndex: %d HasLock: no\n", *info, device->CardIndex());
2016-02-28 17:23:31 +01:00
if (channel) {
if (channel->Number() > 0 && device->Receiving())
info = cString::sprintf("%sTransponder: %d Channel: %s\n", *info, channel->Transponder(), channel->Name());
else
info = cString::sprintf("%sTransponder: %d\n", *info, channel->Transponder());
}
if (timers)
info = cString::sprintf("%sRecording: %d timer%s\n", *info, timers, (timers > 1) ? "s" : "");
info = cString::sprintf("%s\n", *info);
}
}
return isempty(*info) ? cString(tr("SAT>IP information not available!")) : info;
}
2014-03-08 12:07:47 +01:00
cString cSatipDevice::GetGeneralInformation(void)
{
debug16("%s [device %u]", __PRETTY_FUNCTION__, deviceIndexM);
LOCK_CHANNELS_READ;
2014-03-08 12:07:47 +01:00
return cString::sprintf("SAT>IP device: %d\nCardIndex: %d\nStream: %s\nSignal: %s\nStream bitrate: %s\n%sChannel: %s",
deviceIndexM, CardIndex(),
pTunerM ? *pTunerM->GetInformation() : "",
pTunerM ? *pTunerM->GetSignalStatus() : "",
pTunerM ? *pTunerM->GetTunerStatistic() : "",
*GetBufferStatistic(),
*Channels->GetByNumber(cDevice::CurrentChannel())->ToText());
2014-03-08 12:07:47 +01:00
}
cString cSatipDevice::GetPidsInformation(void)
{
debug16("%s [device %u]", __PRETTY_FUNCTION__, deviceIndexM);
2014-03-08 12:07:47 +01:00
return GetPidStatistic();
}
cString cSatipDevice::GetFiltersInformation(void)
{
debug16("%s [device %u]", __PRETTY_FUNCTION__, deviceIndexM);
2014-03-08 12:07:47 +01:00
return cString::sprintf("Active section filters:\n%s", pSectionFilterHandlerM ? *pSectionFilterHandlerM->GetInformation() : "");
}
cString cSatipDevice::GetInformation(unsigned int pageP)
{
// generate information string
cString s;
switch (pageP) {
case SATIP_DEVICE_INFO_GENERAL:
s = GetGeneralInformation();
break;
case SATIP_DEVICE_INFO_PIDS:
s = GetPidsInformation();
break;
case SATIP_DEVICE_INFO_FILTERS:
s = GetFiltersInformation();
break;
case SATIP_DEVICE_INFO_PROTOCOL:
s = pTunerM ? *pTunerM->GetInformation() : "";
break;
case SATIP_DEVICE_INFO_BITRATE:
s = pTunerM ? *pTunerM->GetTunerStatistic() : "";
break;
default:
s = cString::sprintf("%s%s%s",
*GetGeneralInformation(),
*GetPidsInformation(),
*GetFiltersInformation());
break;
}
return s;
}
bool cSatipDevice::Ready(void)
{
debug16("%s [device %u]", __PRETTY_FUNCTION__, deviceIndexM);
2014-03-28 18:53:22 +01:00
return ((cSatipDiscover::GetInstance()->GetServerCount() > 0) || (createdM.Elapsed() > eReadyTimeoutMs));
}
2014-03-08 12:07:47 +01:00
cString cSatipDevice::DeviceType(void) const
{
debug16("%s [device %u]", __PRETTY_FUNCTION__, deviceIndexM);
2014-03-08 12:07:47 +01:00
return "SAT>IP";
}
cString cSatipDevice::DeviceName(void) const
{
debug16("%s [device %u]", __PRETTY_FUNCTION__, deviceIndexM);
if (!Receiving())
return cString::sprintf("%s %d", *DeviceType(), deviceIndexM);
2014-03-08 12:07:47 +01:00
return deviceNameM;
}
bool cSatipDevice::AvoidRecording(void) const
{
debug16("%s [device %u]", __PRETTY_FUNCTION__, deviceIndexM);
return SatipConfig.IsOperatingModeLow();
}
2014-03-08 12:07:47 +01:00
int cSatipDevice::SignalStrength(void) const
{
debug16("%s [device %u]", __PRETTY_FUNCTION__, deviceIndexM);
2014-03-08 12:07:47 +01:00
return (pTunerM ? pTunerM->SignalStrength() : -1);
}
int cSatipDevice::SignalQuality(void) const
{
debug16("%s [device %u]", __PRETTY_FUNCTION__, deviceIndexM);
2014-03-08 12:07:47 +01:00
return (pTunerM ? pTunerM->SignalQuality() : -1);
}
bool cSatipDevice::ProvidesSource(int sourceP) const
{
cSource *s = Sources.Get(sourceP);
debug9("%s (%c) desc='%s' [device %u]", __PRETTY_FUNCTION__, cSource::ToChar(sourceP), s ? s->Description() : "", deviceIndexM);
if (SatipConfig.GetDetachedMode())
return false;
// source descriptions starting with '0' are disabled
if (s && s->Description() && (*(s->Description()) == '0'))
return false;
2014-10-31 21:07:33 +01:00
if (!SatipConfig.IsOperatingModeOff() && !!cSatipDiscover::GetInstance()->GetServer(sourceP)) {
int numDisabledSourcesM = SatipConfig.GetDisabledSourcesCount();
for (int i = 0; i < numDisabledSourcesM; ++i) {
if (sourceP == SatipConfig.GetDisabledSources(i))
return false;
}
return true;
}
return false;
2014-03-08 12:07:47 +01:00
}
bool cSatipDevice::ProvidesTransponder(const cChannel *channelP) const
{
debug9("%s (%d) transponder=%d source=%c [device %u]", __PRETTY_FUNCTION__, channelP ? channelP->Number() : -1, channelP ? channelP->Transponder() : -1, channelP ? cSource::ToChar(channelP->Source()) : '?', deviceIndexM);
if (!ProvidesSource(channelP->Source()))
return false;
return DeviceHooksProvidesTransponder(channelP);
2014-03-08 12:07:47 +01:00
}
bool cSatipDevice::ProvidesChannel(const cChannel *channelP, int priorityP, bool *needsDetachReceiversP) const
{
bool result = false;
bool hasPriority = (priorityP == IDLEPRIORITY) || (priorityP > this->Priority());
bool needsDetachReceivers = false;
debug9("%s (%d, %d, %d) [device %u]", __PRETTY_FUNCTION__, channelP ? channelP->Number() : -1, priorityP, !!needsDetachReceiversP, deviceIndexM);
2014-03-08 12:07:47 +01:00
if (channelP && ProvidesTransponder(channelP)) {
result = hasPriority;
if (priorityP > IDLEPRIORITY) {
if (Receiving()) {
if (IsTunedToTransponder(channelP)) {
if (channelP->Vpid() && !HasPid(channelP->Vpid()) || channelP->Apid(0) && !HasPid(channelP->Apid(0)) || channelP->Dpid(0) && !HasPid(channelP->Dpid(0))) {
if (CamSlot() && channelP->Ca() >= CA_ENCRYPTED_MIN) {
if (CamSlot()->CanDecrypt(channelP))
result = true;
else
needsDetachReceivers = true;
}
else
result = true;
}
else
result = true;
}
else
needsDetachReceivers = Receiving();
}
}
}
if (needsDetachReceiversP)
*needsDetachReceiversP = needsDetachReceivers;
return result;
}
bool cSatipDevice::ProvidesEIT(void) const
{
return (SatipConfig.GetEITScan());
2014-03-08 12:07:47 +01:00
}
int cSatipDevice::NumProvidedSystems(void) const
{
int count = cSatipDiscover::GetInstance()->NumProvidedSystems();
// Tweak the count according to operation mode
if (SatipConfig.IsOperatingModeLow())
count = 15;
else if (SatipConfig.IsOperatingModeHigh())
count = 1;
// Clamp the count between 1 and 15
if (count > 15)
count = 15;
else if (count < 1)
count = 1;
return count;
2014-03-08 12:07:47 +01:00
}
const cChannel *cSatipDevice::GetCurrentlyTunedTransponder(void) const
{
return &channelM;
}
bool cSatipDevice::IsTunedToTransponder(const cChannel *channelP) const
{
if (pTunerM && !pTunerM->IsTuned())
return false;
if ((channelM.Source() != channelP->Source()) || (channelM.Transponder() != channelP->Transponder()))
return false;
return (strcmp(channelM.Parameters(), channelP->Parameters()) == 0);
}
bool cSatipDevice::MaySwitchTransponder(const cChannel *channelP) const
{
return cDevice::MaySwitchTransponder(channelP);
}
bool cSatipDevice::SetChannelDevice(const cChannel *channelP, bool liveViewP)
{
debug9("%s (%d, %d) [device %u]", __PRETTY_FUNCTION__, channelP ? channelP->Number() : -1, liveViewP, deviceIndexM);
2014-03-08 12:07:47 +01:00
if (channelP) {
cDvbTransponderParameters dtp(channelP->Parameters());
cString params = GetTransponderUrlParameters(channelP);
if (isempty(params)) {
error("Unrecognized channel parameters: %s [device %u]", channelP->Parameters(), deviceIndexM);
return false;
}
2014-03-08 12:07:47 +01:00
cString address;
cSatipServer *server = cSatipDiscover::GetInstance()->AssignServer(deviceIndexM, channelP->Source(), channelP->Transponder(), dtp.System());
2014-03-08 12:07:47 +01:00
if (!server) {
debug9("%s No suitable server found [device %u]", __PRETTY_FUNCTION__, deviceIndexM);
2014-03-08 12:07:47 +01:00
return false;
}
2015-01-15 22:33:51 +01:00
if (pTunerM && pTunerM->SetSource(server, channelP->Transponder(), *params, deviceIndexM)) {
2014-03-08 12:07:47 +01:00
channelM = *channelP;
deviceNameM = cString::sprintf("%s %d %s", *DeviceType(), deviceIndexM, *cSatipDiscover::GetInstance()->GetServerString(server));
2014-03-08 12:07:47 +01:00
return true;
}
}
else if (pTunerM) {
2015-01-15 22:33:51 +01:00
pTunerM->SetSource(NULL, 0, NULL, deviceIndexM);
2016-01-30 20:41:10 +01:00
deviceNameM = cString::sprintf("%s %d", *DeviceType(), deviceIndexM);
return true;
}
2014-03-08 12:07:47 +01:00
return false;
}
bool cSatipDevice::SetPid(cPidHandle *handleP, int typeP, bool onP)
{
2015-08-16 00:38:03 +02:00
debug12("%s (%d, %d, %d) [device %u]", __PRETTY_FUNCTION__, handleP ? handleP->pid : -1, typeP, onP, deviceIndexM);
2014-03-08 12:07:47 +01:00
if (pTunerM && handleP && handleP->pid >= 0) {
if (onP)
return pTunerM->SetPid(handleP->pid, typeP, true);
else if (!handleP->used)
return pTunerM->SetPid(handleP->pid, typeP, false);
}
return true;
}
int cSatipDevice::OpenFilter(u_short pidP, u_char tidP, u_char maskP)
{
2015-01-15 19:03:35 +01:00
debug12("%s (%d, %02X, %02X) [device %d]", __PRETTY_FUNCTION__, pidP, tidP, maskP, deviceIndexM);
2014-03-08 12:07:47 +01:00
if (pSectionFilterHandlerM) {
int handle = pSectionFilterHandlerM->Open(pidP, tidP, maskP);
if (pTunerM && (handle >= 0))
2014-03-08 12:07:47 +01:00
pTunerM->SetPid(pidP, ptOther, true);
return handle;
2014-03-08 12:07:47 +01:00
}
return -1;
}
void cSatipDevice::CloseFilter(int handleP)
{
if (pSectionFilterHandlerM) {
int pid = pSectionFilterHandlerM->GetPid(handleP);
2015-01-15 19:03:35 +01:00
debug12("%s (%d) [device %u]", __PRETTY_FUNCTION__, pid, deviceIndexM);
2014-03-08 12:07:47 +01:00
if (pTunerM)
pTunerM->SetPid(pid, ptOther, false);
2014-03-08 12:07:47 +01:00
pSectionFilterHandlerM->Close(handleP);
}
}
bool cSatipDevice::OpenDvr(void)
{
debug9("%s [device %u]", __PRETTY_FUNCTION__, deviceIndexM);
2014-03-08 12:07:47 +01:00
isPacketDeliveredM = false;
tsBufferM->Clear();
if (pTunerM)
pTunerM->Open();
isOpenDvrM = true;
return true;
}
void cSatipDevice::CloseDvr(void)
{
debug9("%s [device %u]", __PRETTY_FUNCTION__, deviceIndexM);
2014-03-08 12:07:47 +01:00
if (pTunerM)
pTunerM->Close();
isOpenDvrM = false;
}
bool cSatipDevice::HasLock(int timeoutMsP) const
{
debug16("%s (%d) [device %d]", __PRETTY_FUNCTION__, timeoutMsP, deviceIndexM);
2014-03-08 12:07:47 +01:00
return (pTunerM && pTunerM->HasLock());
}
bool cSatipDevice::HasInternalCam(void)
{
debug16("%s [device %u]", __PRETTY_FUNCTION__, deviceIndexM);
return SatipConfig.GetCIExtension();
2014-03-08 12:07:47 +01:00
}
void cSatipDevice::WriteData(uchar *bufferP, int lengthP)
{
debug16("%s [device %u]", __PRETTY_FUNCTION__, deviceIndexM);
2014-03-08 12:07:47 +01:00
// Fill up TS buffer
if (isOpenDvrM && tsBufferM) {
2014-03-08 12:07:47 +01:00
int len = tsBufferM->Put(bufferP, lengthP);
if (len != lengthP)
tsBufferM->ReportOverflow(lengthP - len);
}
// Filter the sections
if (pSectionFilterHandlerM)
pSectionFilterHandlerM->Write(bufferP, lengthP);
}
int cSatipDevice::GetId(void)
{
return deviceIndexM;
}
int cSatipDevice::GetPmtPid(void)
{
2015-02-08 21:35:35 +01:00
int pid = channelM.Ca() ? ::GetPmtPid(channelM.Source(), channelM.Transponder(), channelM.Sid()) : 0;
debug11("%s pmtpid=%d source=%c transponder=%d sid=%d name=%s [device %u]", __PRETTY_FUNCTION__, pid, cSource::ToChar(channelM.Source()), channelM.Transponder(), channelM.Sid(), channelM.Name(), deviceIndexM);
return pid;
}
int cSatipDevice::GetCISlot(void)
{
2015-01-11 00:49:59 +01:00
int slot = 0;
int ca = 0;
for (const int *id = channelM.Caids(); *id; ++id) {
if (checkCASystem(SatipConfig.GetCICAM(0), *id)) {
ca = *id;
slot = 1;
break;
}
else if (checkCASystem(SatipConfig.GetCICAM(1), *id)) {
ca = *id;
slot = 2;
break;
}
}
debug11("%s slot=%d ca=%X name=%s [device %u]", __PRETTY_FUNCTION__, slot, ca, channelM.Name(), deviceIndexM);
return slot;
}
cString cSatipDevice::GetTnrParameterString(void)
{
if (channelM.Ca())
return GetTnrUrlParameters(&channelM);
return NULL;
}
bool cSatipDevice::IsIdle(void)
{
return !Receiving();
}
2014-03-08 12:07:47 +01:00
uchar *cSatipDevice::GetData(int *availableP)
{
debug16("%s [device %u]", __PRETTY_FUNCTION__, deviceIndexM);
2014-03-08 12:07:47 +01:00
if (isOpenDvrM && tsBufferM) {
int count = 0;
if (isPacketDeliveredM)
SkipData(TS_SIZE);
uchar *p = tsBufferM->Get(count);
if (p && count >= TS_SIZE) {
if (*p != TS_SYNC_BYTE) {
for (int i = 1; i < count; i++) {
if (p[i] == TS_SYNC_BYTE) {
count = i;
break;
}
}
tsBufferM->Del(count);
info("Skipped %d bytes to sync on TS packet", count);
return NULL;
}
isPacketDeliveredM = true;
if (availableP)
*availableP = count;
// Update pid statistics
AddPidStatistic(ts_pid(p), payload(p));
return p;
}
}
return NULL;
}
void cSatipDevice::SkipData(int countP)
{
debug16("%s [device %u]", __PRETTY_FUNCTION__, deviceIndexM);
2014-03-08 12:07:47 +01:00
tsBufferM->Del(countP);
isPacketDeliveredM = false;
// Update buffer statistics
AddBufferStatistic(countP, tsBufferM->Available());
}
bool cSatipDevice::GetTSPacket(uchar *&dataP)
{
debug16("%s [device %u]", __PRETTY_FUNCTION__, deviceIndexM);
if (SatipConfig.GetDetachedMode())
return false;
2014-03-08 12:07:47 +01:00
if (tsBufferM) {
if (cCamSlot *cs = CamSlot()) {
if (cs->WantsTsData()) {
int available;
dataP = GetData(&available);
if (dataP) {
dataP = cs->Decrypt(dataP, available);
SkipData(available);
}
return true;
}
}
dataP = GetData();
return true;
}
dataP = NULL;
return true;
}