frodovdr
/
vdr-plugin-iptv
mirror of https://github.com/rofafor/vdr-plugin-iptv.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Cleaned up the code.

This commit is contained in:
Rolf Ahrenberg 2013-02-23 15:31:11 +02:00
parent 94461d6c08
commit e75080b1a8
30 changed files with 957 additions and 1009 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
config.c
View File

@ -10,38 +10,38 @@
cIptvConfig IptvConfig; cIptvConfig IptvConfig;
cIptvConfig::cIptvConfig(void) cIptvConfig::cIptvConfig(void)
: tsBufferSize(2), : tsBufferSizeM(2),
tsBufferPrefillRatio(0), tsBufferPrefillRatioM(0),
extProtocolBasePort(4321), extProtocolBasePortM(4321),
useBytes(1), useBytesM(1),
sectionFiltering(1) sectionFilteringM(1)
{ {
for (unsigned int i = 0; i < ARRAY_SIZE(disabledFilters); ++i) for (unsigned int i = 0; i < ARRAY_SIZE(disabledFiltersM); ++i)
disabledFilters[i] = -1; disabledFiltersM[i] = -1;
memset(configDirectory, '\0', sizeof(configDirectory)); memset(configDirectoryM, '\0', sizeof(configDirectoryM));
} }
unsigned int cIptvConfig::GetDisabledFiltersCount(void) const unsigned int cIptvConfig::GetDisabledFiltersCount(void) const
{ {
unsigned int n = 0; unsigned int n = 0;
while ((n < ARRAY_SIZE(disabledFilters) && (disabledFilters[n] != -1))) while ((n < ARRAY_SIZE(disabledFiltersM) && (disabledFiltersM[n] != -1)))
n++; n++;
return n; return n;
} }
int cIptvConfig::GetDisabledFilters(unsigned int Index) const int cIptvConfig::GetDisabledFilters(unsigned int indexP) const
{ {
return (Index < ARRAY_SIZE(disabledFilters)) ? disabledFilters[Index] : -1; return (indexP < ARRAY_SIZE(disabledFiltersM)) ? disabledFiltersM[indexP] : -1;
} }
void cIptvConfig::SetDisabledFilters(unsigned int Index, int Number) void cIptvConfig::SetDisabledFilters(unsigned int indexP, int numberP)
{ {
if (Index < ARRAY_SIZE(disabledFilters)) if (indexP < ARRAY_SIZE(disabledFiltersM))
disabledFilters[Index] = Number; disabledFiltersM[indexP] = numberP;
} }
void cIptvConfig::SetConfigDirectory(const char *directoryP) void cIptvConfig::SetConfigDirectory(const char *directoryP)
{ {
debug("cIptvConfig::SetConfigDirectory(%s)\n", directoryP); debug("cIptvConfig::SetConfigDirectory(%s)\n", directoryP);
ERROR_IF(!realpath(directoryP, configDirectory), "Cannot canonicalize configuration directory"); ERROR_IF(!realpath(directoryP, configDirectoryM), "Cannot canonicalize configuration directory");
} }

40
config.h
View File

@ -14,30 +14,30 @@
class cIptvConfig class cIptvConfig
{ {
private: private:
unsigned int tsBufferSize; unsigned int tsBufferSizeM;
unsigned int tsBufferPrefillRatio; unsigned int tsBufferPrefillRatioM;
unsigned int extProtocolBasePort; unsigned int extProtocolBasePortM;
unsigned int useBytes; unsigned int useBytesM;
unsigned int sectionFiltering; unsigned int sectionFilteringM;
int disabledFilters[SECTION_FILTER_TABLE_SIZE]; int disabledFiltersM[SECTION_FILTER_TABLE_SIZE];
char configDirectory[PATH_MAX]; char configDirectoryM[PATH_MAX];
public: public:
cIptvConfig(); cIptvConfig();
unsigned int GetTsBufferSize(void) const { return tsBufferSize; } unsigned int GetTsBufferSize(void) const { return tsBufferSizeM; }
unsigned int GetTsBufferPrefillRatio(void) const { return tsBufferPrefillRatio; } unsigned int GetTsBufferPrefillRatio(void) const { return tsBufferPrefillRatioM; }
unsigned int GetExtProtocolBasePort(void) const { return extProtocolBasePort; } unsigned int GetExtProtocolBasePort(void) const { return extProtocolBasePortM; }
unsigned int GetUseBytes(void) const { return useBytes; } unsigned int GetUseBytes(void) const { return useBytesM; }
unsigned int GetSectionFiltering(void) const { return sectionFiltering; } unsigned int GetSectionFiltering(void) const { return sectionFilteringM; }
const char *GetConfigDirectory(void) const { return configDirectory; } const char *GetConfigDirectory(void) const { return configDirectoryM; }
unsigned int GetDisabledFiltersCount(void) const; unsigned int GetDisabledFiltersCount(void) const;
int GetDisabledFilters(unsigned int Index) const; int GetDisabledFilters(unsigned int indexP) const;
void SetTsBufferSize(unsigned int Size) { tsBufferSize = Size; } void SetTsBufferSize(unsigned int sizeP) { tsBufferSizeM = sizeP; }
void SetTsBufferPrefillRatio(unsigned int Ratio) { tsBufferPrefillRatio = Ratio; } void SetTsBufferPrefillRatio(unsigned int ratioP) { tsBufferPrefillRatioM = ratioP; }
void SetExtProtocolBasePort(unsigned int PortNumber) { extProtocolBasePort = PortNumber; } void SetExtProtocolBasePort(unsigned int portNumberP) { extProtocolBasePortM = portNumberP; }
void SetUseBytes(unsigned int On) { useBytes = On; } void SetUseBytes(unsigned int onOffP) { useBytesM = onOffP; }
void SetSectionFiltering(unsigned int On) { sectionFiltering = On; } void SetSectionFiltering(unsigned int onOffP) { sectionFilteringM = onOffP; }
void SetDisabledFilters(unsigned int Index, int Number); void SetDisabledFilters(unsigned int indexP, int numberP);
void SetConfigDirectory(const char *directoryP); void SetConfigDirectory(const char *directoryP);
}; };

364
device.c
View File

@ -11,92 +11,89 @@
#define IPTV_MAX_DEVICES MAXDEVICES #define IPTV_MAX_DEVICES MAXDEVICES
static cIptvDevice * IptvDevices[IPTV_MAX_DEVICES] = { NULL }; static cIptvDevice * IptvDevicesS[IPTV_MAX_DEVICES] = { NULL };
unsigned int cIptvDevice::deviceCount = 0; cIptvDevice::cIptvDevice(unsigned int indexP)
: deviceIndexM(indexP),
cIptvDevice::cIptvDevice(unsigned int Index) dvrFdM(-1),
: deviceIndex(Index), isPacketDeliveredM(false),
dvrFd(-1), isOpenDvrM(false),
isPacketDelivered(false), sidScanEnabledM(false),
isOpenDvr(false), pidScanEnabledM(false),
isBuffering(true), channelIdM(tChannelID::InvalidID)
sidScanEnabled(false),
pidScanEnabled(false),
channelId(tChannelID::InvalidID)
{ {
unsigned int bufsize = (unsigned int)MEGABYTE(IptvConfig.GetTsBufferSize()); unsigned int bufsize = (unsigned int)MEGABYTE(IptvConfig.GetTsBufferSize());
bufsize -= (bufsize % TS_SIZE); bufsize -= (bufsize % TS_SIZE);
isyslog("creating IPTV device %d (CardIndex=%d)", deviceIndex, CardIndex()); isyslog("creating IPTV device %d (CardIndex=%d)", deviceIndexM, CardIndex());
tsBuffer = new cRingBufferLinear(bufsize + 1, TS_SIZE, false, tsBufferM = new cRingBufferLinear(bufsize + 1, TS_SIZE, false,
*cString::sprintf("IPTV %d", deviceIndex)); *cString::sprintf("IPTV %d", deviceIndexM));
tsBuffer->SetTimeouts(10, 10); tsBufferM->SetTimeouts(10, 10);
ResetBuffering(); ResetBuffering();
pUdpProtocol = new cIptvProtocolUdp(); pUdpProtocolM = new cIptvProtocolUdp();
pCurlProtocol = new cIptvProtocolCurl(); pCurlProtocolM = new cIptvProtocolCurl();
pHttpProtocol = new cIptvProtocolHttp(); pHttpProtocolM = new cIptvProtocolHttp();
pFileProtocol = new cIptvProtocolFile(); pFileProtocolM = new cIptvProtocolFile();
pExtProtocol = new cIptvProtocolExt(); pExtProtocolM = new cIptvProtocolExt();
pIptvStreamer = new cIptvStreamer(tsBuffer, (100 * TS_SIZE)); pIptvStreamerM = new cIptvStreamer(tsBufferM, (100 * TS_SIZE));
pPidScanner = new cPidScanner(); pPidScannerM = new cPidScanner();
// Initialize filter pointers // Initialize filter pointers
memset(secfilters, '\0', sizeof(secfilters)); memset(secFiltersM, 0, sizeof(secFiltersM));
// Start section handler for iptv device // Start section handler for iptv device
StartSectionHandler(); StartSectionHandler();
// Sid scanner must be created after the section handler // Sid scanner must be created after the section handler
pSidScanner = new cSidScanner(); pSidScannerM = new cSidScanner();
if (pSidScanner) if (pSidScannerM)
AttachFilter(pSidScanner); AttachFilter(pSidScannerM);
// Check if dvr fifo exists // Check if dvr fifo exists
struct stat sb; struct stat sb;
cString filename = cString::sprintf(IPTV_DVR_FILENAME, deviceIndex); cString filename = cString::sprintf(IPTV_DVR_FILENAME, deviceIndexM);
stat(filename, &sb); stat(filename, &sb);
if (S_ISFIFO(sb.st_mode)) { if (S_ISFIFO(sb.st_mode)) {
dvrFd = open(filename, O_RDWR | O_NONBLOCK); dvrFdM = open(filename, O_RDWR | O_NONBLOCK);
if (dvrFd >= 0) if (dvrFdM >= 0)
dsyslog("IPTV device %d redirecting input stream to '%s'", deviceIndex, *filename); dsyslog("IPTV device %d redirecting input stream to '%s'", deviceIndexM, *filename);
} }
} }
cIptvDevice::~cIptvDevice() cIptvDevice::~cIptvDevice()
{ {
debug("cIptvDevice::~cIptvDevice(%d)\n", deviceIndex); debug("cIptvDevice::~cIptvDevice(%d)\n", deviceIndexM);
// Stop section handler of iptv device // Stop section handler of iptv device
StopSectionHandler(); StopSectionHandler();
DELETE_POINTER(pIptvStreamer); DELETE_POINTER(pIptvStreamerM);
DELETE_POINTER(pUdpProtocol); DELETE_POINTER(pUdpProtocolM);
DELETE_POINTER(pCurlProtocol); DELETE_POINTER(pCurlProtocolM);
DELETE_POINTER(pHttpProtocol); DELETE_POINTER(pHttpProtocolM);
DELETE_POINTER(pFileProtocol); DELETE_POINTER(pFileProtocolM);
DELETE_POINTER(pExtProtocol); DELETE_POINTER(pExtProtocolM);
DELETE_POINTER(tsBuffer); DELETE_POINTER(tsBufferM);
DELETE_POINTER(pPidScanner); DELETE_POINTER(pPidScannerM);
// Detach and destroy sid filter // Detach and destroy sid filter
if (pSidScanner) { if (pSidScannerM) {
Detach(pSidScanner); Detach(pSidScannerM);
DELETE_POINTER(pSidScanner); DELETE_POINTER(pSidScannerM);
} }
// Destroy all filters // Destroy all filters
for (int i = 0; i < eMaxSecFilterCount; ++i) for (int i = 0; i < eMaxSecFilterCount; ++i)
DeleteFilter(i); DeleteFilter(i);
// Close dvr fifo // Close dvr fifo
if (dvrFd >= 0) { if (dvrFdM >= 0) {
int fd = dvrFd; int fd = dvrFdM;
dvrFd = -1; dvrFdM = -1;
close(fd); close(fd);
} }
} }
bool cIptvDevice::Initialize(unsigned int DeviceCount) bool cIptvDevice::Initialize(unsigned int deviceCountP)
{ {
debug("cIptvDevice::Initialize(): DeviceCount=%d\n", DeviceCount); debug("cIptvDevice::Initialize(): DeviceCount=%d\n", deviceCountP);
new cIptvSourceParam(IPTV_SOURCE_CHARACTER, "IPTV"); new cIptvSourceParam(IPTV_SOURCE_CHARACTER, "IPTV");
if (DeviceCount > IPTV_MAX_DEVICES) if (deviceCountP > IPTV_MAX_DEVICES)
DeviceCount = IPTV_MAX_DEVICES; deviceCountP = IPTV_MAX_DEVICES;
for (unsigned int i = 0; i < DeviceCount; ++i) for (unsigned int i = 0; i < deviceCountP; ++i)
IptvDevices[i] = new cIptvDevice(i); IptvDevicesS[i] = new cIptvDevice(i);
for (unsigned int i = DeviceCount; i < IPTV_MAX_DEVICES; ++i) for (unsigned int i = deviceCountP; i < IPTV_MAX_DEVICES; ++i)
IptvDevices[i] = NULL; IptvDevicesS[i] = NULL;
return true; return true;
} }
@ -105,19 +102,19 @@ unsigned int cIptvDevice::Count(void)
unsigned int count = 0; unsigned int count = 0;
debug("cIptvDevice::Count()\n"); debug("cIptvDevice::Count()\n");
for (unsigned int i = 0; i < IPTV_MAX_DEVICES; ++i) { for (unsigned int i = 0; i < IPTV_MAX_DEVICES; ++i) {
if (IptvDevices[i] != NULL) if (IptvDevicesS[i] != NULL)
count++; count++;
} }
return count; return count;
} }
cIptvDevice *cIptvDevice::GetIptvDevice(int CardIndex) cIptvDevice *cIptvDevice::GetIptvDevice(int cardIndexP)
{ {
//debug("cIptvDevice::GetIptvDevice(%d)\n", CardIndex); //debug("cIptvDevice::GetIptvDevice(%d)\n", cardIndexP);
for (unsigned int i = 0; i < IPTV_MAX_DEVICES; ++i) { for (unsigned int i = 0; i < IPTV_MAX_DEVICES; ++i) {
if ((IptvDevices[i] != NULL) && (IptvDevices[i]->CardIndex() == CardIndex)) { if ((IptvDevicesS[i] != NULL) && (IptvDevicesS[i]->CardIndex() == cardIndexP)) {
//debug("cIptvDevice::GetIptvDevice(%d): FOUND!\n", CardIndex); //debug("cIptvDevice::GetIptvDevice(%d): FOUND!\n", cardIndexP);
return IptvDevices[i]; return IptvDevicesS[i];
} }
} }
return NULL; return NULL;
@ -125,32 +122,32 @@ cIptvDevice *cIptvDevice::GetIptvDevice(int CardIndex)
cString cIptvDevice::GetGeneralInformation(void) cString cIptvDevice::GetGeneralInformation(void)
{ {
//debug("cIptvDevice::GetGeneralInformation(%d)\n", deviceIndex); //debug("cIptvDevice::GetGeneralInformation(%d)\n", deviceIndexM);
return cString::sprintf("IPTV device: %d\nCardIndex: %d\nStream: %s\nStream bitrate: %s\n%sChannel: %s", return cString::sprintf("IPTV device: %d\nCardIndex: %d\nStream: %s\nStream bitrate: %s\n%sChannel: %s",
deviceIndex, CardIndex(), deviceIndexM, CardIndex(),
pIptvStreamer ? *pIptvStreamer->GetInformation() : "", pIptvStreamerM ? *pIptvStreamerM->GetInformation() : "",
pIptvStreamer ? *pIptvStreamer->GetStreamerStatistic() : "", pIptvStreamerM ? *pIptvStreamerM->GetStreamerStatistic() : "",
*GetBufferStatistic(), *GetBufferStatistic(),
*Channels.GetByNumber(cDevice::CurrentChannel())->ToText()); *Channels.GetByNumber(cDevice::CurrentChannel())->ToText());
} }
cString cIptvDevice::GetPidsInformation(void) cString cIptvDevice::GetPidsInformation(void)
{ {
//debug("cIptvDevice::GetPidsInformation(%d)\n", deviceIndex); //debug("cIptvDevice::GetPidsInformation(%d)\n", deviceIndexM);
return GetPidStatistic(); return GetPidStatistic();
} }
cString cIptvDevice::GetFiltersInformation(void) cString cIptvDevice::GetFiltersInformation(void)
{ {
//debug("cIptvDevice::GetFiltersInformation(%d)\n", deviceIndex); //debug("cIptvDevice::GetFiltersInformation(%d)\n", deviceIndexM);
unsigned int count = 0; unsigned int count = 0;
cString s("Active section filters:\n"); cString s("Active section filters:\n");
// loop through active section filters // loop through active section filters
for (unsigned int i = 0; i < eMaxSecFilterCount; ++i) { for (unsigned int i = 0; i < eMaxSecFilterCount; ++i) {
if (secfilters[i]) { if (secFiltersM[i]) {
s = cString::sprintf("%sFilter %d: %s Pid=0x%02X (%s)\n", *s, i, s = cString::sprintf("%sFilter %d: %s Pid=0x%02X (%s)\n", *s, i,
*secfilters[i]->GetSectionStatistic(), secfilters[i]->GetPid(), *secFiltersM[i]->GetSectionStatistic(), secFiltersM[i]->GetPid(),
id_pid(secfilters[i]->GetPid())); id_pid(secFiltersM[i]->GetPid()));
if (++count > IPTV_STATS_ACTIVE_FILTERS_COUNT) if (++count > IPTV_STATS_ACTIVE_FILTERS_COUNT)
break; break;
} }
@ -158,11 +155,11 @@ cString cIptvDevice::GetFiltersInformation(void)
return s; return s;
} }
cString cIptvDevice::GetInformation(unsigned int Page) cString cIptvDevice::GetInformation(unsigned int pageP)
{ {
// generate information string // generate information string
cString s; cString s;
switch (Page) { switch (pageP) {
case IPTV_DEVICE_INFO_GENERAL: case IPTV_DEVICE_INFO_GENERAL:
s = GetGeneralInformation(); s = GetGeneralInformation();
break; break;
@ -173,10 +170,10 @@ cString cIptvDevice::GetInformation(unsigned int Page)
s = GetFiltersInformation(); s = GetFiltersInformation();
break; break;
case IPTV_DEVICE_INFO_PROTOCOL: case IPTV_DEVICE_INFO_PROTOCOL:
s = pIptvStreamer ? *pIptvStreamer->GetInformation() : ""; s = pIptvStreamerM ? *pIptvStreamerM->GetInformation() : "";
break; break;
case IPTV_DEVICE_INFO_BITRATE: case IPTV_DEVICE_INFO_BITRATE:
s = pIptvStreamer ? *pIptvStreamer->GetStreamerStatistic() : ""; s = pIptvStreamerM ? *pIptvStreamerM->GetStreamerStatistic() : "";
break; break;
default: default:
s = cString::sprintf("%s%s%s", s = cString::sprintf("%s%s%s",
@ -190,59 +187,59 @@ cString cIptvDevice::GetInformation(unsigned int Page)
cString cIptvDevice::DeviceType(void) const cString cIptvDevice::DeviceType(void) const
{ {
debug("cIptvDevice::DeviceType(%d)\n", deviceIndex); debug("cIptvDevice::DeviceType(%d)\n", deviceIndexM);
return "IPTV"; return "IPTV";
} }
cString cIptvDevice::DeviceName(void) const cString cIptvDevice::DeviceName(void) const
{ {
debug("cIptvDevice::DeviceName(%d)\n", deviceIndex); debug("cIptvDevice::DeviceName(%d)\n", deviceIndexM);
return cString::sprintf("IPTV %d", deviceIndex); return cString::sprintf("IPTV %d", deviceIndexM);
} }
int cIptvDevice::SignalStrength(void) const int cIptvDevice::SignalStrength(void) const
{ {
debug("cIptvDevice::SignalStrength(%d)\n", deviceIndex); debug("cIptvDevice::SignalStrength(%d)\n", deviceIndexM);
return (100); return (100);
} }
int cIptvDevice::SignalQuality(void) const int cIptvDevice::SignalQuality(void) const
{ {
debug("cIptvDevice::SignalQuality(%d)\n", deviceIndex); debug("cIptvDevice::SignalQuality(%d)\n", deviceIndexM);
return (100); return (100);
} }
bool cIptvDevice::ProvidesSource(int Source) const bool cIptvDevice::ProvidesSource(int sourceP) const
{ {
debug("cIptvDevice::ProvidesSource(%d)\n", deviceIndex); debug("cIptvDevice::ProvidesSource(%d)\n", deviceIndexM);
return (cSource::IsType(Source, IPTV_SOURCE_CHARACTER)); return (cSource::IsType(sourceP, IPTV_SOURCE_CHARACTER));
} }
bool cIptvDevice::ProvidesTransponder(const cChannel *Channel) const bool cIptvDevice::ProvidesTransponder(const cChannel *channelP) const
{ {
debug("cIptvDevice::ProvidesTransponder(%d)\n", deviceIndex); debug("cIptvDevice::ProvidesTransponder(%d)\n", deviceIndexM);
return (ProvidesSource(Channel->Source())); return (ProvidesSource(channelP->Source()));
} }
bool cIptvDevice::ProvidesChannel(const cChannel *Channel, int Priority, bool *NeedsDetachReceivers) const bool cIptvDevice::ProvidesChannel(const cChannel *channelP, int priorityP, bool *needsDetachReceiversP) const
{ {
bool result = false; bool result = false;
bool hasPriority = Priority == IDLEPRIORITY || Priority > this->Priority(); bool hasPriority = (priorityP == IDLEPRIORITY) || (priorityP > this->Priority());
bool needsDetachReceivers = false; bool needsDetachReceivers = false;
debug("cIptvDevice::ProvidesChannel(%d)\n", deviceIndex); debug("cIptvDevice::ProvidesChannel(%d)\n", deviceIndexM);
if (Channel && ProvidesTransponder(Channel)) { if (channelP && ProvidesTransponder(channelP)) {
result = hasPriority; result = hasPriority;
if (Receiving()) { if (Receiving()) {
if (Channel->GetChannelID() == channelId) if (channelP->GetChannelID() == channelIdM)
result = true; result = true;
else else
needsDetachReceivers = Receiving(); needsDetachReceivers = Receiving();
} }
} }
if (NeedsDetachReceivers) if (needsDetachReceiversP)
*NeedsDetachReceivers = needsDetachReceivers; *needsDetachReceiversP = needsDetachReceivers;
return result; return result;
} }
@ -256,101 +253,101 @@ int cIptvDevice::NumProvidedSystems(void) const
return 1; return 1;
} }
bool cIptvDevice::SetChannelDevice(const cChannel *Channel, bool LiveView) bool cIptvDevice::SetChannelDevice(const cChannel *channelP, bool liveViewP)
{ {
cIptvProtocolIf *protocol; cIptvProtocolIf *protocol;
cIptvTransponderParameters itp(Channel->Parameters()); cIptvTransponderParameters itp(channelP->Parameters());
debug("cIptvDevice::SetChannelDevice(%d)\n", deviceIndex); debug("cIptvDevice::SetChannelDevice(%d)\n", deviceIndexM);
if (isempty(itp.Address())) { if (isempty(itp.Address())) {
error("Unrecognized IPTV address: %s", Channel->Parameters()); error("Unrecognized IPTV address: %s", channelP->Parameters());
return false; return false;
} }
switch (itp.Protocol()) { switch (itp.Protocol()) {
case cIptvTransponderParameters::eProtocolUDP: case cIptvTransponderParameters::eProtocolUDP:
protocol = pUdpProtocol; protocol = pUdpProtocolM;
break; break;
case cIptvTransponderParameters::eProtocolCURL: case cIptvTransponderParameters::eProtocolCURL:
protocol = pCurlProtocol; protocol = pCurlProtocolM;
break; break;
case cIptvTransponderParameters::eProtocolHTTP: case cIptvTransponderParameters::eProtocolHTTP:
protocol = pHttpProtocol; protocol = pHttpProtocolM;
break; break;
case cIptvTransponderParameters::eProtocolFILE: case cIptvTransponderParameters::eProtocolFILE:
protocol = pFileProtocol; protocol = pFileProtocolM;
break; break;
case cIptvTransponderParameters::eProtocolEXT: case cIptvTransponderParameters::eProtocolEXT:
protocol = pExtProtocol; protocol = pExtProtocolM;
break; break;
default: default:
error("Unrecognized IPTV protocol: %s", Channel->Parameters()); error("Unrecognized IPTV protocol: %s", channelP->Parameters());
return false; return false;
break; break;
} }
sidScanEnabled = itp.SidScan() ? true : false; sidScanEnabledM = itp.SidScan() ? true : false;
pidScanEnabled = itp.PidScan() ? true : false; pidScanEnabledM = itp.PidScan() ? true : false;
if (pIptvStreamer->Set(itp.Address(), itp.Parameter(), deviceIndex, protocol)) { if (pIptvStreamerM->Set(itp.Address(), itp.Parameter(), deviceIndexM, protocol)) {
channelId = Channel->GetChannelID(); channelIdM = channelP->GetChannelID();
if (sidScanEnabled && pSidScanner && IptvConfig.GetSectionFiltering()) if (sidScanEnabledM && pSidScannerM && IptvConfig.GetSectionFiltering())
pSidScanner->SetChannel(channelId); pSidScannerM->SetChannel(channelIdM);
if (pidScanEnabled && pPidScanner) if (pidScanEnabledM && pPidScannerM)
pPidScanner->SetChannel(channelId); pPidScannerM->SetChannel(channelIdM);
} }
return true; return true;
} }
bool cIptvDevice::SetPid(cPidHandle *Handle, int Type, bool On) bool cIptvDevice::SetPid(cPidHandle *handleP, int typeP, bool onP)
{ {
debug("cIptvDevice::SetPid(%d) Pid=%d Type=%d On=%d\n", deviceIndex, Handle->pid, Type, On); debug("cIptvDevice::SetPid(%d) Pid=%d Type=%d On=%d\n", deviceIndexM, handleP->pid, typeP, onP);
return true; return true;
} }
bool cIptvDevice::DeleteFilter(unsigned int Index) bool cIptvDevice::DeleteFilter(unsigned int indexP)
{ {
if ((Index < eMaxSecFilterCount) && secfilters[Index]) { if ((indexP < eMaxSecFilterCount) && secFiltersM[indexP]) {
//debug("cIptvDevice::DeleteFilter(%d) Index=%d\n", deviceIndex, Index); //debug("cIptvDevice::DeleteFilter(%d) Index=%d\n", deviceIndexM, indexP);
cIptvSectionFilter *tmp = secfilters[Index]; cIptvSectionFilter *tmp = secFiltersM[indexP];
secfilters[Index] = NULL; secFiltersM[indexP] = NULL;
delete tmp; delete tmp;
return true; return true;
} }
return false; return false;
} }
bool cIptvDevice::IsBlackListed(u_short Pid, u_char Tid, u_char Mask) const bool cIptvDevice::IsBlackListed(u_short pidP, u_char tidP, u_char maskP) const
{ {
//debug("cIptvDevice::IsBlackListed(%d) Pid=%d Tid=%02X Mask=%02X\n", deviceIndex, Pid, Tid, Mask); //debug("cIptvDevice::IsBlackListed(%d) Pid=%d Tid=%02X Mask=%02X\n", deviceIndexM, pidP, tidP, maskP);
// loop through section filter table // loop through section filter table
for (int i = 0; i < SECTION_FILTER_TABLE_SIZE; ++i) { for (int i = 0; i < SECTION_FILTER_TABLE_SIZE; ++i) {
int index = IptvConfig.GetDisabledFilters(i); int index = IptvConfig.GetDisabledFilters(i);
// check if matches // check if matches
if ((index >= 0) && (index < SECTION_FILTER_TABLE_SIZE) && if ((index >= 0) && (index < SECTION_FILTER_TABLE_SIZE) &&
(section_filter_table[index].pid == Pid) && (section_filter_table[index].tid == Tid) && (section_filter_table[index].pid == pidP) && (section_filter_table[index].tid == tidP) &&
(section_filter_table[index].mask == Mask)) { (section_filter_table[index].mask == maskP)) {
//debug("cIptvDevice::IsBlackListed(%d) Found=%s\n", deviceIndex, section_filter_table[index].description); //debug("cIptvDevice::IsBlackListed(%d) Found=%s\n", deviceIndexM, section_filter_table[index].description);
return true; return true;
} }
} }
return false; return false;
} }
int cIptvDevice::OpenFilter(u_short Pid, u_char Tid, u_char Mask) int cIptvDevice::OpenFilter(u_short pidP, u_char tidP, u_char maskP)
{ {
// Check if disabled by user // Check if disabled by user
if (!IptvConfig.GetSectionFiltering()) if (!IptvConfig.GetSectionFiltering())
return -1; return -1;
// Blacklist check, refuse certain filters // Blacklist check, refuse certain filters
if (IsBlackListed(Pid, Tid, Mask)) if (IsBlackListed(pidP, tidP, maskP))
return -1; return -1;
// Lock // Lock
cMutexLock MutexLock(&mutex); cMutexLock MutexLock(&mutexM);
// Search the next free filter slot // Search the next free filter slot
for (unsigned int i = 0; i < eMaxSecFilterCount; ++i) { for (unsigned int i = 0; i < eMaxSecFilterCount; ++i) {
if (!secfilters[i]) { if (!secFiltersM[i]) {
//debug("cIptvDevice::OpenFilter(%d): Pid=%d Tid=%02X Mask=%02X Index=%d\n", deviceIndex, Pid, Tid, Mask, i); //debug("cIptvDevice::OpenFilter(%d): Pid=%d Tid=%02X Mask=%02X Index=%d\n", deviceIndexM, pidP, tidP, maskP, i);
secfilters[i] = new cIptvSectionFilter(deviceIndex, Pid, Tid, Mask); secFiltersM[i] = new cIptvSectionFilter(deviceIndexM, pidP, tidP, maskP);
if (secfilters[i]) if (secFiltersM[i])
return i; return i;
break; break;
} }
@ -359,99 +356,96 @@ int cIptvDevice::OpenFilter(u_short Pid, u_char Tid, u_char Mask)
return -1; return -1;
} }
int cIptvDevice::ReadFilter(int Handle, void *Buffer, size_t Length) int cIptvDevice::ReadFilter(int handleP, void *bufferP, size_t lengthP)
{ {
// Lock // Lock
cMutexLock MutexLock(&mutex); cMutexLock MutexLock(&mutexM);
// ... and load // ... and load
if (secfilters[Handle]) { if (secFiltersM[handleP]) {
return secfilters[Handle]->Read(Buffer, Length); return secFiltersM[handleP]->Read(bufferP, lengthP);
//debug("cIptvDevice::ReadFilter(%d): %d %d\n", deviceIndex, Handle, Length); //debug("cIptvDevice::ReadFilter(%d): %d %d\n", deviceIndexM, handleP, lengthP);
} }
return 0; return 0;
} }
void cIptvDevice::CloseFilter(int Handle) void cIptvDevice::CloseFilter(int handleP)
{ {
// Lock // Lock
cMutexLock MutexLock(&mutex); cMutexLock MutexLock(&mutexM);
// ... and load // ... and load
if (secfilters[Handle]) { if (secFiltersM[handleP]) {
//debug("cIptvDevice::CloseFilter(%d): %d\n", deviceIndex, Handle); //debug("cIptvDevice::CloseFilter(%d): %d\n", deviceIndexM, handleP);
DeleteFilter(Handle); DeleteFilter(handleP);
} }
} }
bool cIptvDevice::OpenDvr(void) bool cIptvDevice::OpenDvr(void)
{ {
debug("cIptvDevice::OpenDvr(%d)\n", deviceIndex); debug("cIptvDevice::OpenDvr(%d)\n", deviceIndexM);
isPacketDelivered = false; isPacketDeliveredM = false;
tsBuffer->Clear(); tsBufferM->Clear();
ResetBuffering(); ResetBuffering();
if (pIptvStreamer) if (pIptvStreamerM)
pIptvStreamer->Open(); pIptvStreamerM->Open();
if (sidScanEnabled && pSidScanner && IptvConfig.GetSectionFiltering()) if (sidScanEnabledM && pSidScannerM && IptvConfig.GetSectionFiltering())
pSidScanner->Open(); pSidScannerM->Open();
isOpenDvr = true; isOpenDvrM = true;
return true; return true;
} }
void cIptvDevice::CloseDvr(void) void cIptvDevice::CloseDvr(void)
{ {
debug("cIptvDevice::CloseDvr(%d)\n", deviceIndex); debug("cIptvDevice::CloseDvr(%d)\n", deviceIndexM);
if (sidScanEnabled && pSidScanner && IptvConfig.GetSectionFiltering()) if (sidScanEnabledM && pSidScannerM && IptvConfig.GetSectionFiltering())
pSidScanner->Close(); pSidScannerM->Close();
if (pIptvStreamer) if (pIptvStreamerM)
pIptvStreamer->Close(); pIptvStreamerM->Close();
isOpenDvr = false; isOpenDvrM = false;
} }
bool cIptvDevice::HasLock(int TimeoutMs) const bool cIptvDevice::HasLock(int timeoutMsP) const
{ {
//debug("cIptvDevice::HasLock(%d): %d\n", deviceIndex, TimeoutMs); //debug("cIptvDevice::HasLock(%d): %d\n", deviceIndexM, timeoutMsP);
return (!isBuffering); return (!IsBuffering());
} }
bool cIptvDevice::HasInternalCam(void) bool cIptvDevice::HasInternalCam(void)
{ {
//debug("cIptvDevice::HasInternalCam(%d)\n", deviceIndex); //debug("cIptvDevice::HasInternalCam(%d)\n", deviceIndexM);
return true; return true;
} }
void cIptvDevice::ResetBuffering(void) void cIptvDevice::ResetBuffering(void)
{ {
debug("cIptvDevice::ResetBuffering(%d)\n", deviceIndex); debug("cIptvDevice::ResetBuffering(%d)\n", deviceIndexM);
isBuffering = true;
// pad prefill to multiple of TS_SIZE // pad prefill to multiple of TS_SIZE
tsBufferPrefill = (unsigned int)MEGABYTE(IptvConfig.GetTsBufferSize()) * tsBufferPrefillM = (unsigned int)MEGABYTE(IptvConfig.GetTsBufferSize()) *
IptvConfig.GetTsBufferPrefillRatio() / 100; IptvConfig.GetTsBufferPrefillRatio() / 100;
tsBufferPrefill -= (tsBufferPrefill % TS_SIZE); tsBufferPrefillM -= (tsBufferPrefillM % TS_SIZE);
} }
void cIptvDevice::CheckBuffering(void) bool cIptvDevice::IsBuffering(void) const
{ {
//debug("cIptvDevice::CheckBuffering(%d): %d\n", deviceIndex); //debug("cIptvDevice::IsBuffering(%d): %d\n", deviceIndexM);
if (tsBufferPrefill && tsBuffer && tsBuffer->Available() < tsBufferPrefill) if (tsBufferPrefillM && tsBufferM && tsBufferM->Available() < tsBufferPrefillM)
isBuffering = true; return true;
else { else
isBuffering = false; tsBufferPrefillM = 0;
tsBufferPrefill = 0; return false;
}
} }
bool cIptvDevice::GetTSPacket(uchar *&Data) bool cIptvDevice::GetTSPacket(uchar *&Data)
{ {
//debug("cIptvDevice::GetTSPacket(%d)\n", deviceIndex); //debug("cIptvDevice::GetTSPacket(%d)\n", deviceIndexM);
CheckBuffering(); if (tsBufferM && !IsBuffering()) {
if (tsBuffer && !isBuffering) { if (isPacketDeliveredM) {
if (isPacketDelivered) { tsBufferM->Del(TS_SIZE);
tsBuffer->Del(TS_SIZE); isPacketDeliveredM = false;
isPacketDelivered = false;
// Update buffer statistics // Update buffer statistics
AddBufferStatistic(TS_SIZE, tsBuffer->Available()); AddBufferStatistic(TS_SIZE, tsBufferM->Available());
} }
int Count = 0; int Count = 0;
uchar *p = tsBuffer->Get(Count); uchar *p = tsBufferM->Get(Count);
if (p && Count >= TS_SIZE) { if (p && Count >= TS_SIZE) {
if (*p != TS_SYNC_BYTE) { if (*p != TS_SYNC_BYTE) {
for (int i = 1; i < Count; i++) { for (int i = 1; i < Count; i++) {
@ -460,26 +454,26 @@ bool cIptvDevice::GetTSPacket(uchar *&Data)
break; break;
} }
} }
tsBuffer->Del(Count); tsBufferM->Del(Count);
error("Skipped %d bytes to sync on TS packet\n", Count); error("Skipped %d bytes to sync on TS packet\n", Count);
return false; return false;
} }
isPacketDelivered = true; isPacketDeliveredM = true;
Data = p; Data = p;
// Update pid statistics // Update pid statistics
AddPidStatistic(ts_pid(p), payload(p)); AddPidStatistic(ts_pid(p), payload(p));
// Send data also to dvr fifo // Send data also to dvr fifo
if (dvrFd >= 0) if (dvrFdM >= 0)
Count = (int)write(dvrFd, p, TS_SIZE); Count = (int)write(dvrFdM, p, TS_SIZE);
// Analyze incomplete streams with built-in pid analyzer // Analyze incomplete streams with built-in pid analyzer
if (pidScanEnabled && pPidScanner) if (pidScanEnabledM && pPidScannerM)
pPidScanner->Process(p); pPidScannerM->Process(p);
// Lock // Lock
cMutexLock MutexLock(&mutex); cMutexLock MutexLock(&mutexM);
// Run the data through all filters // Run the data through all filters
for (unsigned int i = 0; i < eMaxSecFilterCount; ++i) { for (unsigned int i = 0; i < eMaxSecFilterCount; ++i) {
if (secfilters[i]) if (secFiltersM[i])
secfilters[i]->Process(p); secFiltersM[i]->Process(p);
} }
return true; return true;
} }

69
device.h
View File

@ -34,32 +34,31 @@ private:
enum { enum {
eMaxSecFilterCount = 32 eMaxSecFilterCount = 32
}; };
unsigned int deviceIndex; unsigned int deviceIndexM;
int dvrFd; int dvrFdM;
bool isPacketDelivered; bool isPacketDeliveredM;
bool isOpenDvr; bool isOpenDvrM;
bool isBuffering; bool sidScanEnabledM;
bool sidScanEnabled; bool pidScanEnabledM;
bool pidScanEnabled; cRingBufferLinear *tsBufferM;
cRingBufferLinear *tsBuffer; mutable int tsBufferPrefillM;
int tsBufferPrefill; tChannelID channelIdM;
tChannelID channelId; cIptvProtocolUdp *pUdpProtocolM;
cIptvProtocolUdp *pUdpProtocol; cIptvProtocolCurl *pCurlProtocolM;
cIptvProtocolCurl *pCurlProtocol; cIptvProtocolHttp *pHttpProtocolM;
cIptvProtocolHttp *pHttpProtocol; cIptvProtocolFile *pFileProtocolM;
cIptvProtocolFile *pFileProtocol; cIptvProtocolExt *pExtProtocolM;
cIptvProtocolExt *pExtProtocol; cIptvStreamer *pIptvStreamerM;
cIptvStreamer *pIptvStreamer; cPidScanner *pPidScannerM;
cPidScanner *pPidScanner; cSidScanner *pSidScannerM;
cSidScanner *pSidScanner; cMutex mutexM;
cMutex mutex; cIptvSectionFilter *secFiltersM[eMaxSecFilterCount];
cIptvSectionFilter *secfilters[eMaxSecFilterCount];
// constructor & destructor // constructor & destructor
public: public:
cIptvDevice(unsigned int DeviceIndex); cIptvDevice(unsigned int deviceIndexP);
virtual ~cIptvDevice(); virtual ~cIptvDevice();
cString GetInformation(unsigned int Page = IPTV_DEVICE_INFO_ALL); cString GetInformation(unsigned int pageP = IPTV_DEVICE_INFO_ALL);
// copy and assignment constructors // copy and assignment constructors
private: private:
@ -74,9 +73,9 @@ private:
// for channel parsing & buffering // for channel parsing & buffering
private: private:
void ResetBuffering(void); void ResetBuffering(void);
void CheckBuffering(void); bool IsBuffering(void) const;
bool DeleteFilter(unsigned int Index); bool DeleteFilter(unsigned int indexP);
bool IsBlackListed(u_short Pid, u_char Tid, u_char Mask) const; bool IsBlackListed(u_short pidP, u_char tidP, u_char maskP) const;
// for channel info // for channel info
public: public:
@ -87,30 +86,30 @@ public:
// for channel selection // for channel selection
public: public:
virtual bool ProvidesSource(int Source) const; virtual bool ProvidesSource(int sourceP) const;
virtual bool ProvidesTransponder(const cChannel *Channel) const; virtual bool ProvidesTransponder(const cChannel *channelP) const;
virtual bool ProvidesChannel(const cChannel *Channel, int Priority = -1, bool *NeedsDetachReceivers = NULL) const; virtual bool ProvidesChannel(const cChannel *channelP, int priorityP = -1, bool *needsDetachReceiversP = NULL) const;
virtual bool ProvidesEIT(void) const; virtual bool ProvidesEIT(void) const;
virtual int NumProvidedSystems(void) const; virtual int NumProvidedSystems(void) const;
protected: protected:
virtual bool SetChannelDevice(const cChannel *Channel, bool LiveView); virtual bool SetChannelDevice(const cChannel *channelP, bool liveViewP);
// for recording // for recording
protected: protected:
virtual bool SetPid(cPidHandle *Handle, int Type, bool On); virtual bool SetPid(cPidHandle *handleP, int typeP, bool onP);
virtual bool OpenDvr(void); virtual bool OpenDvr(void);
virtual void CloseDvr(void); virtual void CloseDvr(void);
virtual bool GetTSPacket(uchar *&Data); virtual bool GetTSPacket(uchar *&dataP);
// for section filtering // for section filtering
public: public:
virtual int OpenFilter(u_short Pid, u_char Tid, u_char Mask); virtual int OpenFilter(u_short pidP, u_char tidP, u_char maskP);
virtual int ReadFilter(int Handle, void *Buffer, size_t Length); virtual int ReadFilter(int handleP, void *bufferP, size_t lengthP);
virtual void CloseFilter(int Handle); virtual void CloseFilter(int handleP);
// for transponder lock // for transponder lock
public: public:
virtual bool HasLock(int) const; virtual bool HasLock(int timeoutMsP) const;
// for common interface // for common interface
public: public:

68
iptv.c
View File

@ -26,8 +26,8 @@ static const char DESCRIPTION[] = trNOOP("Experience the IPTV");
class cPluginIptv : public cPlugin { class cPluginIptv : public cPlugin {
private: private:
unsigned int deviceCount; unsigned int deviceCountM;
int ParseFilters(const char *Value, int *Values); int ParseFilters(const char *valueP, int *filtersP);
public: public:
cPluginIptv(void); cPluginIptv(void);
virtual ~cPluginIptv(); virtual ~cPluginIptv();
@ -52,7 +52,7 @@ public:
}; };
cPluginIptv::cPluginIptv(void) cPluginIptv::cPluginIptv(void)
: deviceCount(1) : deviceCountM(1)
{ {
//debug("cPluginIptv::cPluginIptv()\n"); //debug("cPluginIptv::cPluginIptv()\n");
// Initialize any member variables here. // Initialize any member variables here.
@ -86,7 +86,7 @@ bool cPluginIptv::ProcessArgs(int argc, char *argv[])
while ((c = getopt_long(argc, argv, "d:", long_options, NULL)) != -1) { while ((c = getopt_long(argc, argv, "d:", long_options, NULL)) != -1) {
switch (c) { switch (c) {
case 'd': case 'd':
deviceCount = atoi(optarg); deviceCountM = atoi(optarg);
break; break;
default: default:
return false; return false;
@ -100,7 +100,7 @@ bool cPluginIptv::Initialize(void)
debug("cPluginIptv::Initialize()\n"); debug("cPluginIptv::Initialize()\n");
// Initialize any background activities the plugin shall perform. // Initialize any background activities the plugin shall perform.
IptvConfig.SetConfigDirectory(cPlugin::ResourceDirectory(PLUGIN_NAME_I18N)); IptvConfig.SetConfigDirectory(cPlugin::ResourceDirectory(PLUGIN_NAME_I18N));
return cIptvDevice::Initialize(deviceCount); return cIptvDevice::Initialize(deviceCountM);
} }
bool cPluginIptv::Start(void) bool cPluginIptv::Start(void)
@ -162,40 +162,40 @@ cMenuSetupPage *cPluginIptv::SetupMenu(void)
return new cIptvPluginSetup(); return new cIptvPluginSetup();
} }
int cPluginIptv::ParseFilters(const char *Value, int *Filters) int cPluginIptv::ParseFilters(const char *valueP, int *filtersP)
{ {
debug("cPluginIptv::ParseFilters(): Value=%s\n", Value); debug("cPluginIptv::ParseFilters(%s)\n", valueP);
char buffer[256]; char buffer[256];
int n = 0; int n = 0;
while (Value && *Value && (n < SECTION_FILTER_TABLE_SIZE)) { while (valueP && *valueP && (n < SECTION_FILTER_TABLE_SIZE)) {
strn0cpy(buffer, Value, sizeof(buffer)); strn0cpy(buffer, valueP, sizeof(buffer));
int i = atoi(buffer); int i = atoi(buffer);
//debug("cPluginIptv::ParseFilters(): Filters[%d]=%d\n", n, i); //debug("cPluginIptv::ParseFilters(): Filters[%d]=%d\n", n, i);
if (i >= 0) if (i >= 0)
Filters[n++] = i; filtersP[n++] = i;
if ((Value = strchr(Value, ' ')) != NULL) if ((valueP = strchr(valueP, ' ')) != NULL)
Value++; valueP++;
} }
return n; return n;
} }
bool cPluginIptv::SetupParse(const char *Name, const char *Value) bool cPluginIptv::SetupParse(const char *nameP, const char *valueP)
{ {
debug("cPluginIptv::SetupParse()\n"); debug("cPluginIptv::SetupParse()\n");
// Parse your own setup parameters and store their values. // Parse your own setup parameters and store their values.
if (!strcasecmp(Name, "TsBufferSize")) if (!strcasecmp(nameP, "TsBufferSize"))
IptvConfig.SetTsBufferSize(atoi(Value)); IptvConfig.SetTsBufferSize(atoi(valueP));
else if (!strcasecmp(Name, "TsBufferPrefill")) else if (!strcasecmp(nameP, "TsBufferPrefill"))
IptvConfig.SetTsBufferPrefillRatio(atoi(Value)); IptvConfig.SetTsBufferPrefillRatio(atoi(valueP));
else if (!strcasecmp(Name, "ExtProtocolBasePort")) else if (!strcasecmp(nameP, "ExtProtocolBasePort"))
IptvConfig.SetExtProtocolBasePort(atoi(Value)); IptvConfig.SetExtProtocolBasePort(atoi(valueP));
else if (!strcasecmp(Name, "SectionFiltering")) else if (!strcasecmp(nameP, "SectionFiltering"))
IptvConfig.SetSectionFiltering(atoi(Value)); IptvConfig.SetSectionFiltering(atoi(valueP));
else if (!strcasecmp(Name, "DisabledFilters")) { else if (!strcasecmp(nameP, "DisabledFilters")) {
int DisabledFilters[SECTION_FILTER_TABLE_SIZE]; int DisabledFilters[SECTION_FILTER_TABLE_SIZE];
for (unsigned int i = 0; i < ARRAY_SIZE(DisabledFilters); ++i) for (unsigned int i = 0; i < ARRAY_SIZE(DisabledFilters); ++i)
DisabledFilters[i] = -1; DisabledFilters[i] = -1;
unsigned int DisabledFiltersCount = ParseFilters(Value, DisabledFilters); unsigned int DisabledFiltersCount = ParseFilters(valueP, DisabledFilters);
for (unsigned int i = 0; i < DisabledFiltersCount; ++i) for (unsigned int i = 0; i < DisabledFiltersCount; ++i)
IptvConfig.SetDisabledFilters(i, DisabledFilters[i]); IptvConfig.SetDisabledFilters(i, DisabledFilters[i]);
} }
@ -204,12 +204,12 @@ bool cPluginIptv::SetupParse(const char *Name, const char *Value)
return true; return true;
} }
bool cPluginIptv::Service(const char *Id, void *Data) bool cPluginIptv::Service(const char *idP, void *dataP)
{ {
debug("cPluginIptv::Service()\n"); debug("cPluginIptv::Service()\n");
if (strcmp(Id,"IptvService-v1.0") == 0) { if (strcmp(idP,"IptvService-v1.0") == 0) {
if (Data) { if (dataP) {
IptvService_v1_0 *data = reinterpret_cast<IptvService_v1_0*>(Data); IptvService_v1_0 *data = reinterpret_cast<IptvService_v1_0*>(dataP);
cIptvDevice *dev = cIptvDevice::GetIptvDevice(data->cardIndex); cIptvDevice *dev = cIptvDevice::GetIptvDevice(data->cardIndex);
if (!dev) if (!dev)
return false; return false;
@ -236,26 +236,26 @@ const char **cPluginIptv::SVDRPHelpPages(void)
return HelpPages; return HelpPages;
} }
cString cPluginIptv::SVDRPCommand(const char *Command, const char *Option, int &ReplyCode) cString cPluginIptv::SVDRPCommand(const char *commandP, const char *optionP, int &replyCodeP)
{ {
debug("cPluginIptv::SVDRPCommand(): Command=%s Option=%s\n", Command, Option); debug("cPluginIptv::SVDRPCommand('%s', %s')\n", commandP, optionP);
if (strcasecmp(Command, "INFO") == 0) { if (strcasecmp(commandP, "INFO") == 0) {
cIptvDevice *device = cIptvDevice::GetIptvDevice(cDevice::ActualDevice()->CardIndex()); cIptvDevice *device = cIptvDevice::GetIptvDevice(cDevice::ActualDevice()->CardIndex());
if (device) { if (device) {
int page = IPTV_DEVICE_INFO_ALL; int page = IPTV_DEVICE_INFO_ALL;
if (Option) { if (optionP) {
page = atoi(Option); page = atoi(optionP);
if ((page < IPTV_DEVICE_INFO_ALL) || (page > IPTV_DEVICE_INFO_FILTERS)) if ((page < IPTV_DEVICE_INFO_ALL) || (page > IPTV_DEVICE_INFO_FILTERS))
page = IPTV_DEVICE_INFO_ALL; page = IPTV_DEVICE_INFO_ALL;
} }
return device->GetInformation(page); return device->GetInformation(page);
} }
else { else {
ReplyCode = 550; // Requested action not taken replyCodeP = 550; // Requested action not taken
return cString("IPTV information not available!"); return cString("IPTV information not available!");
} }
} }
else if (strcasecmp(Command, "MODE") == 0) { else if (strcasecmp(commandP, "MODE") == 0) {
unsigned int mode = !IptvConfig.GetUseBytes(); unsigned int mode = !IptvConfig.GetUseBytes();
IptvConfig.SetUseBytes(mode); IptvConfig.SetUseBytes(mode);
return cString::sprintf("IPTV information mode is: %s\n", mode ? "bytes" : "bits"); return cString::sprintf("IPTV information mode is: %s\n", mode ? "bytes" : "bits");

110
pidscanner.c
View File

@ -14,13 +14,13 @@
#define PIDSCANNER_PID_DELTA_COUNT 100 /* minimum count of pid samples for audio/video only pid detection */ #define PIDSCANNER_PID_DELTA_COUNT 100 /* minimum count of pid samples for audio/video only pid detection */
cPidScanner::cPidScanner(void) cPidScanner::cPidScanner(void)
: timeout(0), : timeoutM(0),
channelId(tChannelID::InvalidID), channelIdM(tChannelID::InvalidID),
process(true), processM(true),
Vpid(0xFFFF), vPidM(0xFFFF),
Apid(0xFFFF), aPidM(0xFFFF),
numVpids(0), numVpidsM(0),
numApids(0) numApidsM(0)
{ {
debug("cPidScanner::cPidScanner()\n"); debug("cPidScanner::cPidScanner()\n");
} }
@ -30,90 +30,90 @@ cPidScanner::~cPidScanner()
debug("cPidScanner::~cPidScanner()\n"); debug("cPidScanner::~cPidScanner()\n");
} }
void cPidScanner::SetChannel(const tChannelID &ChannelId) void cPidScanner::SetChannel(const tChannelID &channelIdP)
{ {
debug("cPidScanner::SetChannel(): %s\n", *ChannelId.ToString()); debug("cPidScanner::SetChannel(): %s\n", *channelIdP.ToString());
channelId = ChannelId; channelIdM = channelIdP;
Vpid = 0xFFFF; vPidM = 0xFFFF;
numVpids = 0; numVpidsM = 0;
Apid = 0xFFFF; aPidM = 0xFFFF;
numApids = 0; numApidsM = 0;
process = true; processM = true;
timeout.Set(PIDSCANNER_TIMEOUT_IN_MS); timeoutM.Set(PIDSCANNER_TIMEOUT_IN_MS);
} }
void cPidScanner::Process(const uint8_t* buf) void cPidScanner::Process(const uint8_t* bufP)
{ {
//debug("cPidScanner::Process()\n"); //debug("cPidScanner::Process()\n");
if (!process) if (!processM)
return; return;
// Stop scanning after defined timeout // Stop scanning after defined timeout
if (timeout.TimedOut()) { if (timeoutM.TimedOut()) {
debug("cPidScanner::Process: Timed out determining pids\n"); debug("cPidScanner::Process: Timed out determining pids\n");
process = false; processM = false;
} }
// Verify TS packet // Verify TS packet
if (buf[0] != 0x47) { if (bufP[0] != 0x47) {
error("Not TS packet: 0x%X\n", buf[0]); error("Not TS packet: 0x%X\n", bufP[0]);
return; return;
} }
// Found TS packet // Found TS packet
int pid = ts_pid(buf); int pid = ts_pid(bufP);
int xpid = (buf[1] << 8 | buf[2]); int xpid = (bufP[1] << 8 | bufP[2]);
// Check if payload available // Check if payload available
uint8_t count = payload(buf); uint8_t count = payload(bufP);
if (count == 0) if (count == 0)
return; return;
if (xpid & 0x4000) { if (xpid & 0x4000) {
// Stream start (Payload Unit Start Indicator) // Stream start (Payload Unit Start Indicator)
uchar *d = (uint8_t*)buf; uchar *d = (uint8_t*)bufP;
d += 4; d += 4;
// pointer to payload // pointer to payload
if (buf[3] & 0x20) if (bufP[3] & 0x20)
d += d[0] + 1; d += d[0] + 1;
// Skip adaption field // Skip adaption field
if (buf[3] & 0x10) { if (bufP[3] & 0x10) {
// Payload present // Payload present
if ((d[0] == 0) && (d[1] == 0) && (d[2] == 1)) { if ((d[0] == 0) && (d[1] == 0) && (d[2] == 1)) {
// PES packet start // PES packet start
int sid = d[3]; int sid = d[3];
// Stream ID // Stream ID
if ((sid >= 0xC0) && (sid <= 0xDF)) { if ((sid >= 0xC0) && (sid <= 0xDF)) {
if (pid < Apid) { if (pid < aPidM) {
debug("cPidScanner::Process: Found lower Apid: 0x%X instead of 0x%X\n", pid, Apid); debug("cPidScanner::Process: Found lower Apid: 0x%X instead of 0x%X\n", pid, aPidM);
Apid = pid; aPidM = pid;
numApids = 1; numApidsM = 1;
} }
else if (pid == Apid) { else if (pid == aPidM) {
++numApids; ++numApidsM;
debug("cPidScanner::Process: Incrementing Apids, now at %d\n", numApids); debug("cPidScanner::Process: Incrementing Apids, now at %d\n", numApidsM);
} }
} }
else if ((sid >= 0xE0) && (sid <= 0xEF)) { else if ((sid >= 0xE0) && (sid <= 0xEF)) {
if (pid < Vpid) { if (pid < vPidM) {
debug("cPidScanner::Process: Found lower Vpid: 0x%X instead of 0x%X\n", pid, Vpid); debug("cPidScanner::Process: Found lower Vpid: 0x%X instead of 0x%X\n", pid, vPidM);
Vpid = pid; vPidM = pid;
numVpids = 1; numVpidsM = 1;
} }
else if (pid == Vpid) { else if (pid == vPidM) {
++numVpids; ++numVpidsM;
debug("cPidScanner::Process: Incrementing Vpids, now at %d\n", numVpids); debug("cPidScanner::Process: Incrementing Vpids, now at %d\n", numVpidsM);
} }
} }
} }
if (((numVpids >= PIDSCANNER_VPID_COUNT) && (numApids >= PIDSCANNER_APID_COUNT)) || if (((numVpidsM >= PIDSCANNER_VPID_COUNT) && (numApidsM >= PIDSCANNER_APID_COUNT)) ||
(abs(numApids - numVpids) >= PIDSCANNER_PID_DELTA_COUNT)) { (abs(numApidsM - numVpidsM) >= PIDSCANNER_PID_DELTA_COUNT)) {
// Lock channels for pid updates // Lock channels for pid updates
if (!Channels.Lock(true, 10)) { if (!Channels.Lock(true, 10)) {
timeout.Set(PIDSCANNER_TIMEOUT_IN_MS); timeoutM.Set(PIDSCANNER_TIMEOUT_IN_MS);
return; return;
} }
cChannel *IptvChannel = Channels.GetByChannelID(channelId); cChannel *IptvChannel = Channels.GetByChannelID(channelIdM);
if (IptvChannel) { if (IptvChannel) {
int Apids[MAXAPIDS + 1] = { 0 }; // these lists are zero-terminated int Apids[MAXAPIDS + 1] = { 0 }; // these lists are zero-terminated
int Atypes[MAXAPIDS + 1] = { 0 }; int Atypes[MAXAPIDS + 1] = { 0 };
@ -127,18 +127,18 @@ void cPidScanner::Process(const uint8_t* buf)
int Ppid = IptvChannel->Ppid(); int Ppid = IptvChannel->Ppid();
int Tpid = IptvChannel->Tpid(); int Tpid = IptvChannel->Tpid();
bool foundApid = false; bool foundApid = false;
if (numVpids < PIDSCANNER_VPID_COUNT) if (numVpidsM < PIDSCANNER_VPID_COUNT)
Vpid = 0; // No detected video pid vPidM = 0; // No detected video pid
else if (numApids < PIDSCANNER_APID_COUNT) else if (numApidsM < PIDSCANNER_APID_COUNT)
Apid = 0; // No detected audio pid aPidM = 0; // No detected audio pid
for (unsigned int i = 0; i < MAXAPIDS; ++i) { for (unsigned int i = 0; i < MAXAPIDS; ++i) {
Apids[i] = IptvChannel->Apid(i); Apids[i] = IptvChannel->Apid(i);
Atypes[i] = IptvChannel->Atype(i); Atypes[i] = IptvChannel->Atype(i);
if (Apids[i] && (Apids[i] == Apid)) if (Apids[i] && (Apids[i] == aPidM))
foundApid = true; foundApid = true;
} }
if (!foundApid) { if (!foundApid) {
Apids[0] = Apid; Apids[0] = aPidM;
Atypes[0] = 4; Atypes[0] = 4;
} }
for (unsigned int i = 0; i < MAXDPIDS; ++i) { for (unsigned int i = 0; i < MAXDPIDS; ++i) {
@ -147,11 +147,11 @@ void cPidScanner::Process(const uint8_t* buf)
} }
for (unsigned int i = 0; i < MAXSPIDS; ++i) for (unsigned int i = 0; i < MAXSPIDS; ++i)
Spids[i] = IptvChannel->Spid(i); Spids[i] = IptvChannel->Spid(i);
debug("cPidScanner::Process(): Vpid=0x%04X, Apid=0x%04X\n", Vpid, Apid); debug("cPidScanner::Process(): Vpid=0x%04X, Apid=0x%04X\n", vPidM, aPidM);
IptvChannel->SetPids(Vpid, Ppid, Vtype, Apids, Atypes, ALangs, Dpids, Dtypes, DLangs, Spids, SLangs, Tpid); IptvChannel->SetPids(vPidM, Ppid, Vtype, Apids, Atypes, ALangs, Dpids, Dtypes, DLangs, Spids, SLangs, Tpid);
} }
Channels.Unlock(); Channels.Unlock();
process = false; processM = false;
} }
} }
} }

18
pidscanner.h
View File

@ -13,19 +13,19 @@
class cPidScanner { class cPidScanner {
private: private:
cTimeMs timeout; cTimeMs timeoutM;
tChannelID channelId; tChannelID channelIdM;
bool process; bool processM;
int Vpid; int vPidM;
int Apid; int aPidM;
int numVpids; int numVpidsM;
int numApids; int numApidsM;
public: public:
cPidScanner(void); cPidScanner(void);
~cPidScanner(); ~cPidScanner();
void SetChannel(const tChannelID &ChannelId); void SetChannel(const tChannelID &channelIdP);
void Process(const uint8_t* buf); void Process(const uint8_t* bufP);
}; };
#endif // __PIDSCANNER_H #endif // __PIDSCANNER_H

22
protocolcurl.c
View File

@ -404,7 +404,7 @@ bool cIptvProtocolCurl::Close(void)
return true; return true;
} }
int cIptvProtocolCurl::Read(unsigned char* BufferAddr, unsigned int BufferLen) int cIptvProtocolCurl::Read(unsigned char* bufferAddrP, unsigned int bufferLenP)
{ {
//debug("cIptvProtocolCurl::Read()\n"); //debug("cIptvProtocolCurl::Read()\n");
int len = 0; int len = 0;
@ -462,11 +462,11 @@ int cIptvProtocolCurl::Read(unsigned char* BufferAddr, unsigned int BufferLen)
} }
// ... and try to empty it // ... and try to empty it
unsigned char *p = GetData(&BufferLen); unsigned char *p = GetData(&bufferLenP);
if (p && (BufferLen > 0)) { if (p && (bufferLenP > 0)) {
memcpy(BufferAddr, p, BufferLen); memcpy(bufferAddrP, p, bufferLenP);
DelData(BufferLen); DelData(bufferLenP);
len = BufferLen; len = bufferLenP;
//debug("cIptvProtocolCurl::Read(): get %d bytes\n", len); //debug("cIptvProtocolCurl::Read(): get %d bytes\n", len);
} }
} }
@ -474,14 +474,14 @@ int cIptvProtocolCurl::Read(unsigned char* BufferAddr, unsigned int BufferLen)
return len; return len;
} }
bool cIptvProtocolCurl::Set(const char* Location, const int Parameter, const int Index) bool cIptvProtocolCurl::Set(const char* locationP, const int parameterP, const int indexP)
{ {
debug("cIptvProtocolCurl::Set(): Location=%s Parameter=%d Index=%d\n", Location, Parameter, Index); debug("cIptvProtocolCurl::Set('%s', %d, %d)\n", locationP, parameterP, indexP);
if (!isempty(Location)) { if (!isempty(locationP)) {
// Disconnect // Disconnect
Disconnect(); Disconnect();
// Update stream URL: colons (%3A) and pipes (%7C) shall be decoded // Update stream URL: colons (%3A) and pipes (%7C) shall be decoded
char *s = strdup(Location); char *s = strdup(locationP);
strreplace(s, "%3A", ":"); strreplace(s, "%3A", ":");
strreplace(s, "%7C", "|"); strreplace(s, "%7C", "|");
streamUrlM = s; streamUrlM = s;
@ -497,7 +497,7 @@ bool cIptvProtocolCurl::Set(const char* Location, const int Parameter, const int
else else
modeM = eModeUnknown; modeM = eModeUnknown;
// Update stream parameter // Update stream parameter
streamParamM = Parameter; streamParamM = parameterP;
//debug("%s [%d]\n", *streamUrlM, streamParamM); //debug("%s [%d]\n", *streamUrlM, streamParamM);
// Reconnect // Reconnect
Connect(); Connect();

4
protocolcurl.h
View File

@ -60,8 +60,8 @@ private:
public: public:
cIptvProtocolCurl(); cIptvProtocolCurl();
virtual ~cIptvProtocolCurl(); virtual ~cIptvProtocolCurl();
int Read(unsigned char* BufferAddr, unsigned int BufferLen); int Read(unsigned char* bufferAddrP, unsigned int bufferLenP);
bool Set(const char* Location, const int Parameter, const int Index); bool Set(const char* locationP, const int parameterP, const int indexP);
bool Open(void); bool Open(void);
bool Close(void); bool Close(void);
cString GetInformation(void); cString GetInformation(void);

68
protocolext.c
View File

@ -24,10 +24,10 @@
#endif #endif
cIptvProtocolExt::cIptvProtocolExt() cIptvProtocolExt::cIptvProtocolExt()
: pid(-1), : pidM(-1),
scriptFile(""), scriptFileM(""),
scriptParameter(0), scriptParameterM(0),
streamPort(0) streamPortM(0)
{ {
debug("cIptvProtocolExt::cIptvProtocolExt()\n"); debug("cIptvProtocolExt::cIptvProtocolExt()\n");
} }
@ -43,22 +43,22 @@ void cIptvProtocolExt::ExecuteScript(void)
{ {
debug("cIptvProtocolExt::ExecuteScript()\n"); debug("cIptvProtocolExt::ExecuteScript()\n");
// Check if already executing // Check if already executing
if (isActive || isempty(scriptFile)) if (isActive || isempty(scriptFileM))
return; return;
if (pid > 0) { if (pidM > 0) {
error("Cannot execute script!"); error("Cannot execute script!");
return; return;
} }
// Let's fork // Let's fork
ERROR_IF_RET((pid = fork()) == -1, "fork()", return); ERROR_IF_RET((pidM = fork()) == -1, "fork()", return);
// Check if child process // Check if child process
if (pid == 0) { if (pidM == 0) {
// Close all dup'ed filedescriptors // Close all dup'ed filedescriptors
int MaxPossibleFileDescriptors = getdtablesize(); int MaxPossibleFileDescriptors = getdtablesize();
for (int i = STDERR_FILENO + 1; i < MaxPossibleFileDescriptors; i++) for (int i = STDERR_FILENO + 1; i < MaxPossibleFileDescriptors; i++)
close(i); close(i);
// Execute the external script // Execute the external script
cString cmd = cString::sprintf("%s %d %d", *scriptFile, scriptParameter, streamPort); cString cmd = cString::sprintf("%s %d %d", *scriptFileM, scriptParameterM, streamPortM);
debug("cIptvProtocolExt::ExecuteScript(child): %s\n", *cmd); debug("cIptvProtocolExt::ExecuteScript(child): %s\n", *cmd);
// Create a new session for a process group // Create a new session for a process group
ERROR_IF_RET(setsid() == -1, "setsid()", _exit(-1)); ERROR_IF_RET(setsid() == -1, "setsid()", _exit(-1));
@ -69,38 +69,38 @@ void cIptvProtocolExt::ExecuteScript(void)
_exit(0); _exit(0);
} }
else { else {
debug("cIptvProtocolExt::ExecuteScript(): pid=%d\n", pid); debug("cIptvProtocolExt::ExecuteScript(): pid=%d\n", pidM);
} }
} }
void cIptvProtocolExt::TerminateScript(void) void cIptvProtocolExt::TerminateScript(void)
{ {
debug("cIptvProtocolExt::TerminateScript(): pid=%d\n", pid); debug("cIptvProtocolExt::TerminateScript(): pid=%d\n", pidM);
if (!isActive || isempty(scriptFile)) if (!isActive || isempty(scriptFileM))
return; return;
if (pid > 0) { if (pidM > 0) {
const unsigned int timeoutms = 100; const unsigned int timeoutms = 100;
unsigned int waitms = 0; unsigned int waitms = 0;
bool waitOver = false; bool waitOver = false;
// Signal and wait for termination // Signal and wait for termination
int retval = killpg(pid, SIGINT); int retval = killpg(pidM, SIGINT);
ERROR_IF_RET(retval < 0, "kill()", waitOver = true); ERROR_IF_RET(retval < 0, "kill()", waitOver = true);
while (!waitOver) { while (!waitOver) {
retval = 0; retval = 0;
waitms += timeoutms; waitms += timeoutms;
if ((waitms % 2000) == 0) { if ((waitms % 2000) == 0) {
error("Script '%s' won't terminate - killing it!", *scriptFile); error("Script '%s' won't terminate - killing it!", *scriptFileM);
killpg(pid, SIGKILL); killpg(pidM, SIGKILL);
} }
// Clear wait status to make sure child exit status is accessible // Clear wait status to make sure child exit status is accessible
// and wait for child termination // and wait for child termination
#ifdef __FreeBSD__ #ifdef __FreeBSD__
int waitStatus = 0; int waitStatus = 0;
retval = waitpid(pid, &waitStatus, WNOHANG); retval = waitpid(pidM, &waitStatus, WNOHANG);
#else // __FreeBSD__ #else // __FreeBSD__
siginfo_t waitStatus; siginfo_t waitStatus;
memset(&waitStatus, '\0', sizeof(waitStatus)); memset(&waitStatus, '\0', sizeof(waitStatus));
retval = waitid(P_PID, pid, &waitStatus, (WNOHANG | WEXITED)); retval = waitid(P_PID, pidM, &waitStatus, (WNOHANG | WEXITED));
#endif // __FreeBSD__ #endif // __FreeBSD__
ERROR_IF_RET(retval < 0, "waitid()", waitOver = true); ERROR_IF_RET(retval < 0, "waitid()", waitOver = true);
// These are the acceptable conditions under which child exit is // These are the acceptable conditions under which child exit is
@ -108,17 +108,17 @@ void cIptvProtocolExt::TerminateScript(void)
#ifdef __FreeBSD__ #ifdef __FreeBSD__
if (retval > 0 && (WIFEXITED(waitStatus) || WIFSIGNALED(waitStatus))) { if (retval > 0 && (WIFEXITED(waitStatus) || WIFSIGNALED(waitStatus))) {
#else // __FreeBSD__ #else // __FreeBSD__
if (!retval && waitStatus.si_pid && (waitStatus.si_pid == pid) && if (!retval && waitStatus.si_pid && (waitStatus.si_pid == pidM) &&
((waitStatus.si_code == CLD_EXITED) || (waitStatus.si_code == CLD_KILLED))) { ((waitStatus.si_code == CLD_EXITED) || (waitStatus.si_code == CLD_KILLED))) {
#endif // __FreeBSD__ #endif // __FreeBSD__
debug("Child (%d) exited as expected\n", pid); debug("Child (%d) exited as expected\n", pidM);
waitOver = true; waitOver = true;
} }
// Unsuccessful wait, avoid busy looping // Unsuccessful wait, avoid busy looping
if (!waitOver) if (!waitOver)
cCondWait::SleepMs(timeoutms); cCondWait::SleepMs(timeoutms);
} }
pid = -1; pidM = -1;
} }
} }
@ -126,10 +126,10 @@ bool cIptvProtocolExt::Open(void)
{ {
debug("cIptvProtocolExt::Open()\n"); debug("cIptvProtocolExt::Open()\n");
// Reject empty script files // Reject empty script files
if (!strlen(*scriptFile)) if (!strlen(*scriptFileM))
return false; return false;
// Create the listening socket // Create the listening socket
OpenSocket(streamPort); OpenSocket(streamPortM);
// Execute the external script // Execute the external script
ExecuteScript(); ExecuteScript();
isActive = true; isActive = true;
@ -147,25 +147,25 @@ bool cIptvProtocolExt::Close(void)
return true; return true;
} }
int cIptvProtocolExt::Read(unsigned char* BufferAddr, unsigned int BufferLen) int cIptvProtocolExt::Read(unsigned char* bufferAddrP, unsigned int bufferLenP)
{ {
return cIptvUdpSocket::Read(BufferAddr, BufferLen); return cIptvUdpSocket::Read(bufferAddrP, bufferLenP);
} }
bool cIptvProtocolExt::Set(const char* Location, const int Parameter, const int Index) bool cIptvProtocolExt::Set(const char* locationP, const int parameterP, const int indexP)
{ {
debug("cIptvProtocolExt::Set(): Location=%s Parameter=%d Index=%d\n", Location, Parameter, Index); debug("cIptvProtocolExt::Set('%s', %d, %d)\n", locationP, parameterP, indexP);
if (!isempty(Location)) { if (!isempty(locationP)) {
struct stat stbuf; struct stat stbuf;
// Update script file and parameter // Update script file and parameter
scriptFile = cString::sprintf("%s/%s", IptvConfig.GetConfigDirectory(), Location); scriptFileM = cString::sprintf("%s/%s", IptvConfig.GetConfigDirectory(), locationP);
if ((stat(*scriptFile, &stbuf) != 0) || (strstr(*scriptFile, "..") != 0)) { if ((stat(*scriptFileM, &stbuf) != 0) || (strstr(*scriptFileM, "..") != 0)) {
error("Non-existent or relative path script '%s'", *scriptFile); error("Non-existent or relative path script '%s'", *scriptFileM);
return false; return false;
} }
scriptParameter = Parameter; scriptParameterM = parameterP;
// Update listen port // Update listen port
streamPort = IptvConfig.GetExtProtocolBasePort() + Index; streamPortM = IptvConfig.GetExtProtocolBasePort() + indexP;
} }
return true; return true;
} }
@ -173,5 +173,5 @@ bool cIptvProtocolExt::Set(const char* Location, const int Parameter, const int
cString cIptvProtocolExt::GetInformation(void) cString cIptvProtocolExt::GetInformation(void)
{ {
//debug("cIptvProtocolExt::GetInformation()"); //debug("cIptvProtocolExt::GetInformation()");
return cString::sprintf("ext://%s:%d", *scriptFile, scriptParameter); return cString::sprintf("ext://%s:%d", *scriptFileM, scriptParameterM);
} }

12
protocolext.h
View File

@ -14,10 +14,10 @@
class cIptvProtocolExt : public cIptvUdpSocket, public cIptvProtocolIf { class cIptvProtocolExt : public cIptvUdpSocket, public cIptvProtocolIf {
private: private:
int pid; int pidM;
cString scriptFile; cString scriptFileM;
int scriptParameter; int scriptParameterM;
int streamPort; int streamPortM;
private: private:
void TerminateScript(void); void TerminateScript(void);
@ -26,8 +26,8 @@ private:
public: public:
cIptvProtocolExt(); cIptvProtocolExt();
virtual ~cIptvProtocolExt(); virtual ~cIptvProtocolExt();
int Read(unsigned char* BufferAddr, unsigned int BufferLen); int Read(unsigned char* bufferAddrP, unsigned int bufferLenP);
bool Set(const char* Location, const int Parameter, const int Index); bool Set(const char* locationP, const int parameterP, const int indexP);
bool Open(void); bool Open(void);
bool Close(void); bool Close(void);
cString GetInformation(void); cString GetInformation(void);

52
protocolfile.c
View File

@ -15,12 +15,12 @@
#include "protocolfile.h" #include "protocolfile.h"
cIptvProtocolFile::cIptvProtocolFile() cIptvProtocolFile::cIptvProtocolFile()
: fileDelay(0), : fileLocationM(strdup("")),
fileStream(NULL), fileDelayM(0),
isActive(false) fileStreamM(NULL),
isActiveM(false)
{ {
debug("cIptvProtocolFile::cIptvProtocolFile()\n"); debug("cIptvProtocolFile::cIptvProtocolFile()\n");
fileLocation = strdup("");
} }
cIptvProtocolFile::~cIptvProtocolFile() cIptvProtocolFile::~cIptvProtocolFile()
@ -29,18 +29,18 @@ cIptvProtocolFile::~cIptvProtocolFile()
// Drop open handles // Drop open handles
cIptvProtocolFile::Close(); cIptvProtocolFile::Close();
// Free allocated memory // Free allocated memory
free(fileLocation); free(fileLocationM);
} }
bool cIptvProtocolFile::OpenFile(void) bool cIptvProtocolFile::OpenFile(void)
{ {
debug("cIptvProtocolFile::OpenFile()\n"); debug("cIptvProtocolFile::OpenFile()\n");
// Check that stream address is valid // Check that stream address is valid
if (!isActive && !isempty(fileLocation)) { if (!isActiveM && !isempty(fileLocationM)) {
fileStream = fopen(fileLocation, "rb"); fileStreamM = fopen(fileLocationM, "rb");
ERROR_IF_RET(!fileStream || ferror(fileStream), "fopen()", return false); ERROR_IF_RET(!fileStreamM || ferror(fileStreamM), "fopen()", return false);
// Update active flag // Update active flag
isActive = true; isActiveM = true;
} }
return true; return true;
} }
@ -49,33 +49,33 @@ void cIptvProtocolFile::CloseFile(void)
{ {
debug("cIptvProtocolFile::CloseFile()\n"); debug("cIptvProtocolFile::CloseFile()\n");
// Check that file stream is valid // Check that file stream is valid
if (isActive && !isempty(fileLocation)) { if (isActiveM && !isempty(fileLocationM)) {
fclose(fileStream); fclose(fileStreamM);
// Update active flag // Update active flag
isActive = false; isActiveM = false;
} }
} }
int cIptvProtocolFile::Read(unsigned char* BufferAddr, unsigned int BufferLen) int cIptvProtocolFile::Read(unsigned char* bufferAddrP, unsigned int bufferLenP)
{ {
//debug("cIptvProtocolFile::Read()\n"); //debug("cIptvProtocolFile::Read()\n");
// Check errors // Check errors
if (ferror(fileStream)) { if (ferror(fileStreamM)) {
debug("Read error\n"); debug("Read error\n");
return -1; return -1;
} }
// Rewind if EOF // Rewind if EOF
if (feof(fileStream)) if (feof(fileStreamM))
rewind(fileStream); rewind(fileStreamM);
// Sleep before reading the file stream to prevent aggressive busy looping // Sleep before reading the file stream to prevent aggressive busy looping
// and prevent transfer ringbuffer overflows // and prevent transfer ringbuffer overflows
if (fileDelay) if (fileDelayM)
cCondWait::SleepMs(fileDelay); cCondWait::SleepMs(fileDelayM);
// This check is to prevent a race condition where file may be switched off // This check is to prevent a race condition where file may be switched off
// during the sleep and buffers are disposed. Check here that the plugin is // during the sleep and buffers are disposed. Check here that the plugin is
// still active before accessing the buffers // still active before accessing the buffers
if (isActive) if (isActiveM)
return (int)fread(BufferAddr, sizeof(unsigned char), BufferLen, fileStream); return (int)fread(bufferAddrP, sizeof(unsigned char), bufferLenP, fileStreamM);
return -1; return -1;
} }
@ -95,15 +95,15 @@ bool cIptvProtocolFile::Close(void)
return true; return true;
} }
bool cIptvProtocolFile::Set(const char* Location, const int Parameter, const int Index) bool cIptvProtocolFile::Set(const char* locationP, const int parameterP, const int indexP)
{ {
debug("cIptvProtocolFile::Set(): Location=%s Parameter=%d Index=%d\n", Location, Parameter, Index); debug("cIptvProtocolFile::Set('%s', %d, %d)\n", locationP, parameterP, indexP);
if (!isempty(Location)) { if (!isempty(locationP)) {
// Close the file stream // Close the file stream
CloseFile(); CloseFile();
// Update stream address and port // Update stream address and port
fileLocation = strcpyrealloc(fileLocation, Location); fileLocationM = strcpyrealloc(fileLocationM, locationP);
fileDelay = Parameter; fileDelayM = parameterP;
// Open the file for input // Open the file for input
OpenFile(); OpenFile();
} }
@ -113,5 +113,5 @@ bool cIptvProtocolFile::Set(const char* Location, const int Parameter, const int
cString cIptvProtocolFile::GetInformation(void) cString cIptvProtocolFile::GetInformation(void)
{ {
//debug("cIptvProtocolFile::GetInformation()"); //debug("cIptvProtocolFile::GetInformation()");
return cString::sprintf("file://%s:%d", fileLocation, fileDelay); return cString::sprintf("file://%s:%d", fileLocationM, fileDelayM);
} }

12
protocolfile.h
View File

@ -13,10 +13,10 @@
class cIptvProtocolFile : public cIptvProtocolIf { class cIptvProtocolFile : public cIptvProtocolIf {
private: private:
char* fileLocation; char* fileLocationM;
int fileDelay; int fileDelayM;
FILE* fileStream; FILE* fileStreamM;
bool isActive; bool isActiveM;
private: private:
bool OpenFile(void); bool OpenFile(void);
@ -25,8 +25,8 @@ private:
public: public:
cIptvProtocolFile(); cIptvProtocolFile();
virtual ~cIptvProtocolFile(); virtual ~cIptvProtocolFile();
int Read(unsigned char* BufferAddr, unsigned int BufferLen); int Read(unsigned char* bufferAddrP, unsigned int bufferLenP);
bool Set(const char* Location, const int Parameter, const int Index); bool Set(const char* locationP, const int parameterP, const int indexP);
bool Open(void); bool Open(void);
bool Close(void); bool Close(void);
cString GetInformation(void); cString GetInformation(void);

57
protocolhttp.c
View File

@ -19,9 +19,9 @@
#include "protocolhttp.h" #include "protocolhttp.h"
cIptvProtocolHttp::cIptvProtocolHttp() cIptvProtocolHttp::cIptvProtocolHttp()
: streamAddr(strdup("")), : streamAddrM(strdup("")),
streamPath(strdup("/")), streamPathM(strdup("/")),
streamPort(0) streamPortM(0)
{ {
debug("cIptvProtocolHttp::cIptvProtocolHttp()\n"); debug("cIptvProtocolHttp::cIptvProtocolHttp()\n");
} }
@ -32,17 +32,17 @@ cIptvProtocolHttp::~cIptvProtocolHttp()
// Close the socket // Close the socket
cIptvProtocolHttp::Close(); cIptvProtocolHttp::Close();
// Free allocated memory // Free allocated memory
free(streamPath); free(streamPathM);
free(streamAddr); free(streamAddrM);
} }
bool cIptvProtocolHttp::Connect(void) bool cIptvProtocolHttp::Connect(void)
{ {
debug("cIptvProtocolHttp::Connect()\n"); debug("cIptvProtocolHttp::Connect()\n");
// Check that stream address is valid // Check that stream address is valid
if (!isActive && !isempty(streamAddr) && !isempty(streamPath)) { if (!isActive && !isempty(streamAddrM) && !isempty(streamPathM)) {
// Ensure that socket is valid and connect // Ensure that socket is valid and connect
OpenSocket(streamPort, streamAddr); OpenSocket(streamPortM, streamAddrM);
if (!ConnectSocket()) { if (!ConnectSocket()) {
CloseSocket(); CloseSocket();
return false; return false;
@ -53,7 +53,8 @@ bool cIptvProtocolHttp::Connect(void)
"User-Agent: vdr-%s/%s\r\n" "User-Agent: vdr-%s/%s\r\n"
"Range: bytes=0-\r\n" "Range: bytes=0-\r\n"
"Connection: Close\r\n" "Connection: Close\r\n"
"\r\n", streamPath, streamAddr, PLUGIN_NAME_I18N, VERSION); "\r\n", streamPathM, streamAddrM,
PLUGIN_NAME_I18N, VERSION);
debug("Sending http request: %s\n", *buffer); debug("Sending http request: %s\n", *buffer);
if (!Write(*buffer, (unsigned int)strlen(*buffer))) { if (!Write(*buffer, (unsigned int)strlen(*buffer))) {
CloseSocket(); CloseSocket();
@ -82,16 +83,16 @@ bool cIptvProtocolHttp::Disconnect(void)
return true; return true;
} }
bool cIptvProtocolHttp::GetHeaderLine(char* dest, unsigned int destLen, bool cIptvProtocolHttp::GetHeaderLine(char* destP, unsigned int destLenP,
unsigned int &recvLen) unsigned int &recvLenP)
{ {
debug("cIptvProtocolHttp::GetHeaderLine()\n"); debug("cIptvProtocolHttp::GetHeaderLine()\n");
bool linefeed = false; bool linefeed = false;
bool newline = false; bool newline = false;
char *bufptr = dest; char *bufptr = destP;
recvLen = 0; recvLenP = 0;
if (!dest) if (!destP)
return false; return false;
while (!newline || !linefeed) { while (!newline || !linefeed) {
@ -106,13 +107,13 @@ bool cIptvProtocolHttp::GetHeaderLine(char* dest, unsigned int destLen,
// Saw just data or \r without \n // Saw just data or \r without \n
else { else {
linefeed = false; linefeed = false;
++recvLen; ++recvLenP;
} }
++bufptr; ++bufptr;
// Check that buffer won't be exceeded // Check that buffer won't be exceeded
if (recvLen >= destLen) { if (recvLenP >= destLenP) {
error("Header wouldn't fit into buffer\n"); error("Header wouldn't fit into buffer\n");
recvLen = 0; recvLenP = 0;
return false; return false;
} }
} }
@ -170,28 +171,28 @@ bool cIptvProtocolHttp::Close(void)
return true; return true;
} }
int cIptvProtocolHttp::Read(unsigned char* BufferAddr, unsigned int BufferLen) int cIptvProtocolHttp::Read(unsigned char* bufferAddrP, unsigned int bufferLenP)
{ {
return cIptvTcpSocket::Read(BufferAddr, BufferLen); return cIptvTcpSocket::Read(bufferAddrP, bufferLenP);
} }
bool cIptvProtocolHttp::Set(const char* Location, const int Parameter, const int Index) bool cIptvProtocolHttp::Set(const char* locationP, const int parameterP, const int indexP)
{ {
debug("cIptvProtocolHttp::Set(): Location=%s Parameter=%d Index=%d\n", Location, Parameter, Index); debug("cIptvProtocolHttp::Set('%s', %d, %d)\n", locationP, parameterP, indexP);
if (!isempty(Location)) { if (!isempty(locationP)) {
// Disconnect the current socket // Disconnect the current socket
Disconnect(); Disconnect();
// Update stream address, path and port // Update stream address, path and port
streamAddr = strcpyrealloc(streamAddr, Location); streamAddrM = strcpyrealloc(streamAddrM, locationP);
char *path = strstr(streamAddr, "/"); char *path = strstr(streamAddrM, "/");
if (path) { if (path) {
streamPath = strcpyrealloc(streamPath, path); streamPathM = strcpyrealloc(streamPathM, path);
*path = 0; *path = 0;
} }
else else
streamPath = strcpyrealloc(streamPath, "/"); streamPathM = strcpyrealloc(streamPathM, "/");
streamPort = Parameter; streamPortM = parameterP;
//debug("http://%s:%d%s\n", streamAddr, streamPort, streamPath); //debug("http://%s:%d%s\n", streamAddrM, streamPortM, streamPathM);
// Re-connect the socket // Re-connect the socket
Connect(); Connect();
} }
@ -201,5 +202,5 @@ bool cIptvProtocolHttp::Set(const char* Location, const int Parameter, const int
cString cIptvProtocolHttp::GetInformation(void) cString cIptvProtocolHttp::GetInformation(void)
{ {
//debug("cIptvProtocolHttp::GetInformation()"); //debug("cIptvProtocolHttp::GetInformation()");
return cString::sprintf("http://%s:%d%s", streamAddr, streamPort, streamPath); return cString::sprintf("http://%s:%d%s", streamAddrM, streamPortM, streamPathM);
} }

12
protocolhttp.h
View File

@ -14,21 +14,21 @@
class cIptvProtocolHttp : public cIptvTcpSocket, public cIptvProtocolIf { class cIptvProtocolHttp : public cIptvTcpSocket, public cIptvProtocolIf {
private: private:
char* streamAddr; char* streamAddrM;
char* streamPath; char* streamPathM;
int streamPort; int streamPortM;
private: private:
bool Connect(void); bool Connect(void);
bool Disconnect(void); bool Disconnect(void);
bool GetHeaderLine(char* dest, unsigned int destLen, unsigned int &recvLen); bool GetHeaderLine(char* destP, unsigned int destLenP, unsigned int &recvLenP);
bool ProcessHeaders(void); bool ProcessHeaders(void);
public: public:
cIptvProtocolHttp(); cIptvProtocolHttp();
virtual ~cIptvProtocolHttp(); virtual ~cIptvProtocolHttp();
int Read(unsigned char* BufferAddr, unsigned int BufferLen); int Read(unsigned char* bufferAddrP, unsigned int bufferLenP);
bool Set(const char* Location, const int Parameter, const int Index); bool Set(const char* locationP, const int parameterP, const int indexP);
bool Open(void); bool Open(void);
bool Close(void); bool Close(void);
cString GetInformation(void); cString GetInformation(void);

4
protocolif.h
View File

@ -12,8 +12,8 @@ class cIptvProtocolIf {
public: public:
cIptvProtocolIf() {} cIptvProtocolIf() {}
virtual ~cIptvProtocolIf() {} virtual ~cIptvProtocolIf() {}
virtual int Read(unsigned char* BufferAddr, unsigned int BufferLen) = 0; virtual int Read(unsigned char* bufferAddrP, unsigned int bufferLenP) = 0;
virtual bool Set(const char* Location, const int Parameter, const int Index) = 0; virtual bool Set(const char* locationP, const int parameterP, const int indexP) = 0;
virtual bool Open(void) = 0; virtual bool Open(void) = 0;
virtual bool Close(void) = 0; virtual bool Close(void) = 0;
virtual cString GetInformation(void) = 0; virtual cString GetInformation(void) = 0;

70
protocoludp.c
View File

@ -19,10 +19,10 @@
#include "socket.h" #include "socket.h"
cIptvProtocolUdp::cIptvProtocolUdp() cIptvProtocolUdp::cIptvProtocolUdp()
: isIGMPv3(false), : isIGMPv3M(false),
sourceAddr(strdup("")), sourceAddrM(strdup("")),
streamAddr(strdup("")), streamAddrM(strdup("")),
streamPort(0) streamPortM(0)
{ {
debug("cIptvProtocolUdp::cIptvProtocolUdp()\n"); debug("cIptvProtocolUdp::cIptvProtocolUdp()\n");
} }
@ -33,15 +33,15 @@ cIptvProtocolUdp::~cIptvProtocolUdp()
// Drop the multicast group and close the socket // Drop the multicast group and close the socket
cIptvProtocolUdp::Close(); cIptvProtocolUdp::Close();
// Free allocated memory // Free allocated memory
free(streamAddr); free(streamAddrM);
free(sourceAddr); free(sourceAddrM);
} }
bool cIptvProtocolUdp::Open(void) bool cIptvProtocolUdp::Open(void)
{ {
debug("cIptvProtocolUdp::Open(): streamAddr=%s\n", streamAddr); debug("cIptvProtocolUdp::Open(): '%s'\n", streamAddrM);
OpenSocket(streamPort, streamAddr, sourceAddr, isIGMPv3); OpenSocket(streamPortM, streamAddrM, sourceAddrM, isIGMPv3M);
if (!isempty(streamAddr)) { if (!isempty(streamAddrM)) {
// Join a new multicast group // Join a new multicast group
JoinMulticast(); JoinMulticast();
} }
@ -50,53 +50,53 @@ bool cIptvProtocolUdp::Open(void)
bool cIptvProtocolUdp::Close(void) bool cIptvProtocolUdp::Close(void)
{ {
debug("cIptvProtocolUdp::Close(): streamAddr=%s\n", streamAddr); debug("cIptvProtocolUdp::Close(): '%s'\n", streamAddrM);
if (!isempty(streamAddr)) { if (!isempty(streamAddrM)) {
// Drop the multicast group // Drop the multicast group
OpenSocket(streamPort, streamAddr, sourceAddr, isIGMPv3); OpenSocket(streamPortM, streamAddrM, sourceAddrM, isIGMPv3M);
DropMulticast(); DropMulticast();
} }
// Close the socket // Close the socket
CloseSocket(); CloseSocket();
// Do NOT reset stream and source addresses // Do NOT reset stream and source addresses
//sourceAddr = strcpyrealloc(sourceAddr, ""); //sourceAddrM = strcpyrealloc(sourceAddrM, "");
//streamAddr = strcpyrealloc(streamAddr, ""); //streamAddrM = strcpyrealloc(streamAddrM, "");
//streamPort = 0; //streamPortM = 0;
return true; return true;
} }
int cIptvProtocolUdp::Read(unsigned char* BufferAddr, unsigned int BufferLen) int cIptvProtocolUdp::Read(unsigned char* bufferAddrP, unsigned int bufferLenP)
{ {
return cIptvUdpSocket::Read(BufferAddr, BufferLen); return cIptvUdpSocket::Read(bufferAddrP, bufferLenP);
} }
bool cIptvProtocolUdp::Set(const char* Location, const int Parameter, const int Index) bool cIptvProtocolUdp::Set(const char* locationP, const int parameterP, const int indexP)
{ {
debug("cIptvProtocolUdp::Set(): Location=%s Parameter=%d Index=%d\n", Location, Parameter, Index); debug("cIptvProtocolUdp::Set('%s', %d, %d)\n", locationP, parameterP, indexP);
if (!isempty(Location)) { if (!isempty(locationP)) {
// Drop the multicast group // Drop the multicast group
if (!isempty(streamAddr)) { if (!isempty(streamAddrM)) {
OpenSocket(streamPort, streamAddr, sourceAddr, isIGMPv3); OpenSocket(streamPortM, streamAddrM, sourceAddrM, isIGMPv3M);
DropMulticast(); DropMulticast();
} }
// Update stream address and port // Update stream address and port
streamAddr = strcpyrealloc(streamAddr, Location); streamAddrM = strcpyrealloc(streamAddrM, locationP);
// <group address> or <source address>@<group address> // <group address> or <source address>@<group address>
char *p = strstr(streamAddr, "@"); char *p = strstr(streamAddrM, "@");
if (p) { if (p) {
*p = 0; *p = 0;
sourceAddr = strcpyrealloc(sourceAddr, streamAddr); sourceAddrM = strcpyrealloc(sourceAddrM, streamAddrM);
streamAddr = strcpyrealloc(streamAddr, p + 1); streamAddrM = strcpyrealloc(streamAddrM, p + 1);
isIGMPv3 = true; isIGMPv3M = true;
} }
else { else {
sourceAddr = strcpyrealloc(sourceAddr, streamAddr); sourceAddrM = strcpyrealloc(sourceAddrM, streamAddrM);
isIGMPv3 = false; isIGMPv3M = false;
} }
streamPort = Parameter; streamPortM = parameterP;
// Join a new multicast group // Join a new multicast group
if (!isempty(streamAddr)) { if (!isempty(streamAddrM)) {
OpenSocket(streamPort, streamAddr, sourceAddr, isIGMPv3); OpenSocket(streamPortM, streamAddrM, sourceAddrM, isIGMPv3M);
JoinMulticast(); JoinMulticast();
} }
} }
@ -106,7 +106,7 @@ bool cIptvProtocolUdp::Set(const char* Location, const int Parameter, const int
cString cIptvProtocolUdp::GetInformation(void) cString cIptvProtocolUdp::GetInformation(void)
{ {
//debug("cIptvProtocolUdp::GetInformation()"); //debug("cIptvProtocolUdp::GetInformation()");
if (isIGMPv3) if (isIGMPv3M)
return cString::sprintf("udp://%s@%s:%d", sourceAddr, streamAddr, streamPort); return cString::sprintf("udp://%s@%s:%d", sourceAddrM, streamAddrM, streamPortM);
return cString::sprintf("udp://%s:%d", streamAddr, streamPort); return cString::sprintf("udp://%s:%d", streamAddrM, streamPortM);
} }

12
protocoludp.h
View File

@ -14,16 +14,16 @@
class cIptvProtocolUdp : public cIptvUdpSocket, public cIptvProtocolIf { class cIptvProtocolUdp : public cIptvUdpSocket, public cIptvProtocolIf {
private: private:
bool isIGMPv3; bool isIGMPv3M;
char* sourceAddr; char* sourceAddrM;
char* streamAddr; char* streamAddrM;
int streamPort; int streamPortM;
public: public:
cIptvProtocolUdp(); cIptvProtocolUdp();
virtual ~cIptvProtocolUdp(); virtual ~cIptvProtocolUdp();
int Read(unsigned char* BufferAddr, unsigned int BufferLen); int Read(unsigned char* bufferAddrP, unsigned int bufferLenP);
bool Set(const char* Location, const int Parameter, const int Index); bool Set(const char* locationP, const int parameterP, const int indexP);
bool Open(void); bool Open(void);
bool Close(void); bool Close(void);
cString GetInformation(void); cString GetInformation(void);

170
sectionfilter.c
View File

@ -8,101 +8,101 @@
#include "config.h" #include "config.h"
#include "sectionfilter.h" #include "sectionfilter.h"
cIptvSectionFilter::cIptvSectionFilter(int DeviceIndex, uint16_t Pid, uint8_t Tid, uint8_t Mask) cIptvSectionFilter::cIptvSectionFilter(int deviceIndexP, uint16_t pidP, uint8_t tidP, uint8_t maskP)
: pusi_seen(0), : pusiSeenM(0),
feedcc(0), feedCcM(0),
doneq(0), doneqM(0),
secbuf(NULL), secBufM(NULL),
secbufp(0), secBufpM(0),
seclen(0), secLenM(0),
tsfeedp(0), tsFeedpM(0),
pid(Pid), pidM(pidP),
devid(DeviceIndex) devIdM(deviceIndexP)
{ {
//debug("cIptvSectionFilter::cIptvSectionFilter(%d, %d)\n", devid, pid); //debug("cIptvSectionFilter::cIptvSectionFilter(%d, %d)\n", devIdM, pidM);
int i; int i;
memset(secbuf_base, '\0', sizeof(secbuf_base)); memset(secBufBaseM, 0, sizeof(secBufBaseM));
memset(filter_value, '\0', sizeof(filter_value)); memset(filterValueM, 0, sizeof(filterValueM));
memset(filter_mask, '\0', sizeof(filter_mask)); memset(filterMaskM, 0, sizeof(filterMaskM));
memset(filter_mode, '\0', sizeof(filter_mode)); memset(filterModeM, 0, sizeof(filterModeM));
memset(maskandmode, '\0', sizeof(maskandmode)); memset(maskAndModeM, 0, sizeof(maskAndModeM));
memset(maskandnotmode, '\0', sizeof(maskandnotmode)); memset(maskAndNotModeM, 0, sizeof(maskAndNotModeM));
filter_value[0] = Tid; filterValueM[0] = tidP;
filter_mask[0] = Mask; filterMaskM[0] = maskP;
// Invert the filter // Invert the filter
for (i = 0; i < DMX_MAX_FILTER_SIZE; ++i) for (i = 0; i < DMX_MAX_FILTER_SIZE; ++i)
filter_value[i] ^= 0xff; filterValueM[i] ^= 0xFF;
uint8_t mask, mode, local_doneq = 0; uint8_t mask, mode, doneq = 0;
for (i = 0; i < DMX_MAX_FILTER_SIZE; ++i) { for (i = 0; i < DMX_MAX_FILTER_SIZE; ++i) {
mode = filter_mode[i]; mode = filterModeM[i];
mask = filter_mask[i]; mask = filterMaskM[i];
maskandmode[i] = (uint8_t)(mask & mode); maskAndModeM[i] = (uint8_t)(mask & mode);
maskandnotmode[i] = (uint8_t)(mask & ~mode); maskAndNotModeM[i] = (uint8_t)(mask & ~mode);
local_doneq |= maskandnotmode[i]; doneq |= maskAndNotModeM[i];
} }
doneq = local_doneq ? 1 : 0; doneqM = doneq ? 1 : 0;
// Create filtering buffer // Create filtering buffer
ringbuffer = new cRingBufferLinear(KILOBYTE(128), 0, false, *cString::sprintf("IPTV SECTION %d/%d", devid, pid)); ringbufferM = new cRingBufferLinear(KILOBYTE(128), 0, false, *cString::sprintf("IPTV SECTION %d/%d", devIdM, pidM));
if (ringbuffer) if (ringbufferM)
ringbuffer->SetTimeouts(10, 10); ringbufferM->SetTimeouts(10, 10);
else else
error("Failed to allocate buffer for section filter (device=%d pid=%d): ", devid, pid); error("Failed to allocate buffer for section filter (device=%d pid=%d): ", devIdM, pidM);
} }
cIptvSectionFilter::~cIptvSectionFilter() cIptvSectionFilter::~cIptvSectionFilter()
{ {
//debug("cIptvSectionFilter::~cIptvSectionfilter(%d, %d)\n", devid, pid); //debug("cIptvSectionFilter::~cIptvSectionfilter(%d, %d)\n", devIdM, pidM);
DELETE_POINTER(ringbuffer); DELETE_POINTER(ringbufferM);
secbuf = NULL; secBufM = NULL;
} }
int cIptvSectionFilter::Read(void *Data, size_t Length) int cIptvSectionFilter::Read(void *Data, size_t Length)
{ {
int count = 0; int count = 0;
uchar *p = ringbuffer->Get(count); uchar *p = ringbufferM->Get(count);
if (p && count > 0) { if (p && count > 0) {
memcpy(Data, p, count); memcpy(Data, p, count);
ringbuffer->Del(count); ringbufferM->Del(count);
} }
return count; return count;
} }
inline uint16_t cIptvSectionFilter::GetLength(const uint8_t *Data) inline uint16_t cIptvSectionFilter::GetLength(const uint8_t *dataP)
{ {
return (uint16_t)(3 + ((Data[1] & 0x0f) << 8) + Data[2]); return (uint16_t)(3 + ((dataP[1] & 0x0f) << 8) + dataP[2]);
} }
void cIptvSectionFilter::New(void) void cIptvSectionFilter::New(void)
{ {
tsfeedp = secbufp = seclen = 0; tsFeedpM = secBufpM = secLenM = 0;
secbuf = secbuf_base; secBufM = secBufBaseM;
} }
int cIptvSectionFilter::Filter(void) int cIptvSectionFilter::Filter(void)
{ {
if (secbuf) { if (secBufM) {
int i; int i;
uint8_t neq = 0; uint8_t neq = 0;
for (i = 0; i < DMX_MAX_FILTER_SIZE; ++i) { for (i = 0; i < DMX_MAX_FILTER_SIZE; ++i) {
uint8_t local_xor = (uint8_t)(filter_value[i] ^ secbuf[i]); uint8_t calcxor = (uint8_t)(filterValueM[i] ^ secBufM[i]);
if (maskandmode[i] & local_xor) if (maskAndModeM[i] & calcxor)
return 0; return 0;
neq |= (maskandnotmode[i] & local_xor); neq |= (maskAndNotModeM[i] & calcxor);
} }
if (doneq && !neq) if (doneqM && !neq)
return 0; return 0;
if (ringbuffer) { if (ringbufferM) {
int len = ringbuffer->Put(secbuf, seclen); int len = ringbufferM->Put(secBufM, secLenM);
if (len != seclen) if (len != secLenM)
ringbuffer->ReportOverflow(seclen - len); ringbufferM->ReportOverflow(secLenM - len);
// Update statistics // Update statistics
AddSectionStatistic(len, 1); AddSectionStatistic(len, 1);
} }
@ -114,56 +114,56 @@ inline int cIptvSectionFilter::Feed(void)
{ {
if (Filter() < 0) if (Filter() < 0)
return -1; return -1;
seclen = 0; secLenM = 0;
return 0; return 0;
} }
int cIptvSectionFilter::CopyDump(const uint8_t *buf, uint8_t len) int cIptvSectionFilter::CopyDump(const uint8_t *bufP, uint8_t lenP)
{ {
uint16_t limit, seclen_local, n; uint16_t limit, seclen, n;
if (tsfeedp >= DMX_MAX_SECFEED_SIZE) if (tsFeedpM >= DMX_MAX_SECFEED_SIZE)
return 0; return 0;
if (tsfeedp + len > DMX_MAX_SECFEED_SIZE) if (tsFeedpM + lenP > DMX_MAX_SECFEED_SIZE)
len = (uint8_t)(DMX_MAX_SECFEED_SIZE - tsfeedp); lenP = (uint8_t)(DMX_MAX_SECFEED_SIZE - tsFeedpM);
if (len <= 0) if (lenP <= 0)
return 0; return 0;
memcpy(secbuf_base + tsfeedp, buf, len); memcpy(secBufBaseM + tsFeedpM, bufP, lenP);
tsfeedp = uint16_t(tsfeedp + len); tsFeedpM = uint16_t(tsFeedpM + lenP);
limit = tsfeedp; limit = tsFeedpM;
if (limit > DMX_MAX_SECFEED_SIZE) if (limit > DMX_MAX_SECFEED_SIZE)
return -1; // internal error should never happen return -1; // internal error should never happen
// Always set secbuf // Always set secbuf
secbuf = secbuf_base + secbufp; secBufM = secBufBaseM + secBufpM;
for (n = 0; secbufp + 2 < limit; ++n) { for (n = 0; secBufpM + 2 < limit; ++n) {
seclen_local = GetLength(secbuf); seclen = GetLength(secBufM);
if ((seclen_local <= 0) || (seclen_local > DMX_MAX_SECTION_SIZE) || ((seclen_local + secbufp) > limit)) if ((seclen <= 0) || (seclen > DMX_MAX_SECTION_SIZE) || ((seclen + secBufpM) > limit))
return 0; return 0;
seclen = seclen_local; secLenM = seclen;
if (pusi_seen) if (pusiSeenM)
Feed(); Feed();
secbufp = uint16_t(secbufp + seclen_local); secBufpM = uint16_t(secBufpM + seclen);
secbuf += seclen_local; secBufM += seclen;
} }
return 0; return 0;
} }
void cIptvSectionFilter::Process(const uint8_t* Data) void cIptvSectionFilter::Process(const uint8_t* dataP)
{ {
if (Data[0] != TS_SYNC_BYTE) if (dataP[0] != TS_SYNC_BYTE)
return; return;
// Stop if not the PID this filter is looking for // Stop if not the PID this filter is looking for
if (ts_pid(Data) != pid) if (ts_pid(dataP) != pidM)
return; return;
uint8_t count = payload(Data); uint8_t count = payload(dataP);
// Check if no payload or out of range // Check if no payload or out of range
if (count == 0) if (count == 0)
@ -172,41 +172,41 @@ void cIptvSectionFilter::Process(const uint8_t* Data)
// Payload start // Payload start
uint8_t p = (uint8_t)(TS_SIZE - count); uint8_t p = (uint8_t)(TS_SIZE - count);
uint8_t cc = (uint8_t)(Data[3] & 0x0f); uint8_t cc = (uint8_t)(dataP[3] & 0x0f);
int ccok = ((feedcc + 1) & 0x0f) == cc; int ccok = ((feedCcM + 1) & 0x0f) == cc;
feedcc = cc; feedCcM = cc;
int dc_i = 0; int dc_i = 0;
if (Data[3] & 0x20) { if (dataP[3] & 0x20) {
// Adaption field present, check for discontinuity_indicator // Adaption field present, check for discontinuity_indicator
if ((Data[4] > 0) && (Data[5] & 0x80)) if ((dataP[4] > 0) && (dataP[5] & 0x80))
dc_i = 1; dc_i = 1;
} }
if (!ccok || dc_i) { if (!ccok || dc_i) {
// Discontinuity detected. Reset pusi_seen = 0 to // Discontinuity detected. Reset pusiSeenM = 0 to
// stop feeding of suspicious data until next PUSI=1 arrives // stop feeding of suspicious data until next PUSI=1 arrives
pusi_seen = 0; pusiSeenM = 0;
New(); New();
} }
if (Data[1] & 0x40) { if (dataP[1] & 0x40) {
// PUSI=1 (is set), section boundary is here // PUSI=1 (is set), section boundary is here
if (count > 1 && Data[p] < count) { if (count > 1 && dataP[p] < count) {
const uint8_t *before = &Data[p + 1]; const uint8_t *before = &dataP[p + 1];
uint8_t before_len = Data[p]; uint8_t before_len = dataP[p];
const uint8_t *after = &before[before_len]; const uint8_t *after = &before[before_len];
uint8_t after_len = (uint8_t)(count - 1 - before_len); uint8_t after_len = (uint8_t)(count - 1 - before_len);
CopyDump(before, before_len); CopyDump(before, before_len);
// Before start of new section, set pusi_seen = 1 // Before start of new section, set pusiSeenM = 1
pusi_seen = 1; pusiSeenM = 1;
New(); New();
CopyDump(after, after_len); CopyDump(after, after_len);
} }
} }
else { else {
// PUSI=0 (is not set), no section boundary // PUSI=0 (is not set), no section boundary
CopyDump(&Data[p], count); CopyDump(&dataP[p], count);
} }
} }

44
sectionfilter.h
View File

@ -24,41 +24,41 @@ private:
DMX_MAX_SECFEED_SIZE = (DMX_MAX_SECTION_SIZE + TS_SIZE) DMX_MAX_SECFEED_SIZE = (DMX_MAX_SECTION_SIZE + TS_SIZE)
}; };
int pusi_seen; int pusiSeenM;
int feedcc; int feedCcM;
int doneq; int doneqM;
uint8_t *secbuf; uint8_t *secBufM;
uint8_t secbuf_base[DMX_MAX_SECFEED_SIZE]; uint8_t secBufBaseM[DMX_MAX_SECFEED_SIZE];
uint16_t secbufp; uint16_t secBufpM;
uint16_t seclen; uint16_t secLenM;
uint16_t tsfeedp; uint16_t tsFeedpM;
uint16_t pid; uint16_t pidM;
int devid; int devIdM;
uint8_t filter_value[DMX_MAX_FILTER_SIZE]; uint8_t filterValueM[DMX_MAX_FILTER_SIZE];
uint8_t filter_mask[DMX_MAX_FILTER_SIZE]; uint8_t filterMaskM[DMX_MAX_FILTER_SIZE];
uint8_t filter_mode[DMX_MAX_FILTER_SIZE]; uint8_t filterModeM[DMX_MAX_FILTER_SIZE];
uint8_t maskandmode[DMX_MAX_FILTER_SIZE]; uint8_t maskAndModeM[DMX_MAX_FILTER_SIZE];
uint8_t maskandnotmode[DMX_MAX_FILTER_SIZE]; uint8_t maskAndNotModeM[DMX_MAX_FILTER_SIZE];
cRingBufferLinear *ringbuffer; cRingBufferLinear *ringbufferM;
inline uint16_t GetLength(const uint8_t *Data); inline uint16_t GetLength(const uint8_t *dataP);
void New(void); void New(void);
int Filter(void); int Filter(void);
inline int Feed(void); inline int Feed(void);
int CopyDump(const uint8_t *buf, uint8_t len); int CopyDump(const uint8_t *bufP, uint8_t lenP);
public: public:
// constructor & destructor // constructor & destructor
cIptvSectionFilter(int DeviceIndex, uint16_t Pid, uint8_t Tid, uint8_t Mask); cIptvSectionFilter(int deviceIndexP, uint16_t pidP, uint8_t tidP, uint8_t maskP);
virtual ~cIptvSectionFilter(); virtual ~cIptvSectionFilter();
void Process(const uint8_t* Data); void Process(const uint8_t* dataP);
int Read(void *Buffer, size_t Length); int Read(void *bufferP, size_t lengthP);
uint16_t GetPid(void) const { return pid; } uint16_t GetPid(void) const { return pidM; }
}; };
#endif // __IPTV_SECTIONFILTER_H #endif // __IPTV_SECTIONFILTER_H

142
setup.c
View File

@ -21,23 +21,23 @@ private:
enum { enum {
INFO_TIMEOUT_MS = 2000 INFO_TIMEOUT_MS = 2000
}; };
cString text; cString textM;
cTimeMs timeout; cTimeMs timeoutM;
unsigned int page; unsigned int pageM;
void UpdateInfo(); void UpdateInfo();
public: public:
cIptvMenuInfo(); cIptvMenuInfo();
virtual ~cIptvMenuInfo(); virtual ~cIptvMenuInfo();
virtual void Display(void); virtual void Display(void);
virtual eOSState ProcessKey(eKeys Key); virtual eOSState ProcessKey(eKeys keyP);
}; };
cIptvMenuInfo::cIptvMenuInfo() cIptvMenuInfo::cIptvMenuInfo()
:cOsdMenu(tr("IPTV Information")), text(""), timeout(), page(IPTV_DEVICE_INFO_GENERAL) :cOsdMenu(tr("IPTV Information")), textM(""), timeoutM(), pageM(IPTV_DEVICE_INFO_GENERAL)
{ {
SetMenuCategory(mcText); SetMenuCategory(mcText);
timeout.Set(INFO_TIMEOUT_MS); timeoutM.Set(INFO_TIMEOUT_MS);
UpdateInfo(); UpdateInfo();
SetHelp(tr("General"), tr("Pids"), tr("Filters"), tr("Bits/bytes")); SetHelp(tr("General"), tr("Pids"), tr("Filters"), tr("Bits/bytes"));
} }
@ -50,24 +50,24 @@ void cIptvMenuInfo::UpdateInfo()
{ {
cIptvDevice *device = cIptvDevice::GetIptvDevice(cDevice::ActualDevice()->CardIndex()); cIptvDevice *device = cIptvDevice::GetIptvDevice(cDevice::ActualDevice()->CardIndex());
if (device) if (device)
text = device->GetInformation(page); textM = device->GetInformation(pageM);
else else
text = cString(tr("IPTV information not available!")); textM = cString(tr("IPTV information not available!"));
Display(); Display();
timeout.Set(INFO_TIMEOUT_MS); timeoutM.Set(INFO_TIMEOUT_MS);
} }
void cIptvMenuInfo::Display(void) void cIptvMenuInfo::Display(void)
{ {
cOsdMenu::Display(); cOsdMenu::Display();
DisplayMenu()->SetText(text, true); DisplayMenu()->SetText(textM, true);
if (*text) if (*textM)
cStatus::MsgOsdTextItem(text); cStatus::MsgOsdTextItem(textM);
} }
eOSState cIptvMenuInfo::ProcessKey(eKeys Key) eOSState cIptvMenuInfo::ProcessKey(eKeys keyP)
{ {
switch (int(Key)) { switch (int(keyP)) {
case kUp|k_Repeat: case kUp|k_Repeat:
case kUp: case kUp:
case kDown|k_Repeat: case kDown|k_Repeat:
@ -76,30 +76,30 @@ eOSState cIptvMenuInfo::ProcessKey(eKeys Key)
case kLeft: case kLeft:
case kRight|k_Repeat: case kRight|k_Repeat:
case kRight: case kRight:
DisplayMenu()->Scroll(NORMALKEY(Key) == kUp || NORMALKEY(Key) == kLeft, NORMALKEY(Key) == kLeft || NORMALKEY(Key) == kRight); DisplayMenu()->Scroll(NORMALKEY(keyP) == kUp || NORMALKEY(keyP) == kLeft, NORMALKEY(keyP) == kLeft || NORMALKEY(keyP) == kRight);
cStatus::MsgOsdTextItem(NULL, NORMALKEY(Key) == kUp || NORMALKEY(Key) == kLeft); cStatus::MsgOsdTextItem(NULL, NORMALKEY(keyP) == kUp || NORMALKEY(keyP) == kLeft);
return osContinue; return osContinue;
default: break; default: break;
} }
eOSState state = cOsdMenu::ProcessKey(Key); eOSState state = cOsdMenu::ProcessKey(keyP);
if (state == osUnknown) { if (state == osUnknown) {
switch (Key) { switch (keyP) {
case kOk: return osBack; case kOk: return osBack;
case kRed: page = IPTV_DEVICE_INFO_GENERAL; case kRed: pageM = IPTV_DEVICE_INFO_GENERAL;
UpdateInfo(); UpdateInfo();
break; break;
case kGreen: page = IPTV_DEVICE_INFO_PIDS; case kGreen: pageM = IPTV_DEVICE_INFO_PIDS;
UpdateInfo(); UpdateInfo();
break; break;
case kYellow: page = IPTV_DEVICE_INFO_FILTERS; case kYellow: pageM = IPTV_DEVICE_INFO_FILTERS;
UpdateInfo(); UpdateInfo();
break; break;
case kBlue: IptvConfig.SetUseBytes(IptvConfig.GetUseBytes() ? 0 : 1); case kBlue: IptvConfig.SetUseBytes(IptvConfig.GetUseBytes() ? 0 : 1);
UpdateInfo(); UpdateInfo();
break; break;
default: if (timeout.TimedOut()) default: if (timeoutM.TimedOut())
UpdateInfo(); UpdateInfo();
state = osContinue; state = osContinue;
break; break;
@ -113,16 +113,16 @@ eOSState cIptvMenuInfo::ProcessKey(eKeys Key)
cIptvPluginSetup::cIptvPluginSetup() cIptvPluginSetup::cIptvPluginSetup()
{ {
debug("cIptvPluginSetup::cIptvPluginSetup()\n"); debug("cIptvPluginSetup::cIptvPluginSetup()\n");
tsBufferSize = IptvConfig.GetTsBufferSize(); tsBufferSizeM = IptvConfig.GetTsBufferSize();
tsBufferPrefill = IptvConfig.GetTsBufferPrefillRatio(); tsBufferPrefillM = IptvConfig.GetTsBufferPrefillRatio();
extProtocolBasePort = IptvConfig.GetExtProtocolBasePort(); extProtocolBasePortM = IptvConfig.GetExtProtocolBasePort();
sectionFiltering = IptvConfig.GetSectionFiltering(); sectionFilteringM = IptvConfig.GetSectionFiltering();
numDisabledFilters = IptvConfig.GetDisabledFiltersCount(); numDisabledFiltersM = IptvConfig.GetDisabledFiltersCount();
if (numDisabledFilters > SECTION_FILTER_TABLE_SIZE) if (numDisabledFiltersM > SECTION_FILTER_TABLE_SIZE)
numDisabledFilters = SECTION_FILTER_TABLE_SIZE; numDisabledFiltersM = SECTION_FILTER_TABLE_SIZE;
for (int i = 0; i < SECTION_FILTER_TABLE_SIZE; ++i) { for (int i = 0; i < SECTION_FILTER_TABLE_SIZE; ++i) {
disabledFilterIndexes[i] = IptvConfig.GetDisabledFilters(i); disabledFilterIndexesM[i] = IptvConfig.GetDisabledFilters(i);
disabledFilterNames[i] = tr(section_filter_table[i].description); disabledFilterNamesM[i] = tr(section_filter_table[i].description);
} }
Setup(); Setup();
SetHelp(NULL, NULL, NULL, trVDR("Button$Info")); SetHelp(NULL, NULL, NULL, trVDR("Button$Info"));
@ -133,28 +133,28 @@ void cIptvPluginSetup::Setup(void)
int current = Current(); int current = Current();
Clear(); Clear();
help.Clear(); helpM.Clear();
Add(new cMenuEditIntItem( tr("TS buffer size [MB]"), &tsBufferSize, 1, 4)); Add(new cMenuEditIntItem( tr("TS buffer size [MB]"), &tsBufferSizeM, 1, 4));
help.Append(tr("Define a ringbuffer size for transport streams in megabytes.\n\nSmaller sizes help memory consumption, but are more prone to buffer overflows.")); helpM.Append(tr("Define a ringbuffer size for transport streams in megabytes.\n\nSmaller sizes help memory consumption, but are more prone to buffer overflows."));
Add(new cMenuEditIntItem( tr("TS buffer prefill ratio [%]"), &tsBufferPrefill, 0, 40)); Add(new cMenuEditIntItem( tr("TS buffer prefill ratio [%]"), &tsBufferPrefillM, 0, 40));
help.Append(tr("Define a prefill ratio of the ringbuffer for transport streams before data is transferred to VDR.\n\nThis is useful if streaming media over a slow or unreliable connection.")); helpM.Append(tr("Define a prefill ratio of the ringbuffer for transport streams before data is transferred to VDR.\n\nThis is useful if streaming media over a slow or unreliable connection."));
Add(new cMenuEditIntItem( tr("EXT protocol base port"), &extProtocolBasePort, 0, 0xFFF7)); Add(new cMenuEditIntItem( tr("EXT protocol base port"), &extProtocolBasePortM, 0, 0xFFF7));
help.Append(tr("Define a base port used by EXT protocol.\n\nThe port range is defined by the number of IPTV devices. This setting sets the port which is listened for connections from external applications when using the EXT protocol.")); helpM.Append(tr("Define a base port used by EXT protocol.\n\nThe port range is defined by the number of IPTV devices. This setting sets the port which is listened for connections from external applications when using the EXT protocol."));
Add(new cMenuEditBoolItem(tr("Use section filtering"), &sectionFiltering)); Add(new cMenuEditBoolItem(tr("Use section filtering"), &sectionFilteringM));
help.Append(tr("Define whether the section filtering shall be used.\n\nSection filtering means that IPTV plugin tries to parse and provide VDR with secondary data about the currently active stream. VDR can then use this data for providing various functionalities such as automatic pid change detection and EPG etc.\nEnabling this feature does not affect streams that do not contain section data.")); helpM.Append(tr("Define whether the section filtering shall be used.\n\nSection filtering means that IPTV plugin tries to parse and provide VDR with secondary data about the currently active stream. VDR can then use this data for providing various functionalities such as automatic pid change detection and EPG etc.\nEnabling this feature does not affect streams that do not contain section data."));
if (sectionFiltering) { if (sectionFilteringM) {
Add(new cMenuEditIntItem( tr("Disable filters"), &numDisabledFilters, 0, SECTION_FILTER_TABLE_SIZE)); Add(new cMenuEditIntItem( tr("Disable filters"), &numDisabledFiltersM, 0, SECTION_FILTER_TABLE_SIZE));
help.Append(tr("Define number of section filters to be disabled.\n\nCertain section filters might cause some unwanted behaviour to VDR such as time being falsely synchronized. By black-listing the filters here useful section data can be left intact for VDR to process.")); helpM.Append(tr("Define number of section filters to be disabled.\n\nCertain section filters might cause some unwanted behaviour to VDR such as time being falsely synchronized. By black-listing the filters here useful section data can be left intact for VDR to process."));
for (int i = 0; i < numDisabledFilters; ++i) { for (int i = 0; i < numDisabledFiltersM; ++i) {
// TRANSLATORS: note the singular! // TRANSLATORS: note the singular!
Add(new cMenuEditStraItem(tr("Disable filter"), &disabledFilterIndexes[i], SECTION_FILTER_TABLE_SIZE, disabledFilterNames)); Add(new cMenuEditStraItem(tr("Disable filter"), &disabledFilterIndexesM[i], SECTION_FILTER_TABLE_SIZE, disabledFilterNamesM));
help.Append(tr("Define an ill-behaving filter to be blacklisted.")); helpM.Append(tr("Define an ill-behaving filter to be blacklisted."));
} }
} }
@ -170,62 +170,62 @@ eOSState cIptvPluginSetup::ShowInfo(void)
return AddSubMenu(new cIptvMenuInfo()); return AddSubMenu(new cIptvMenuInfo());
} }
eOSState cIptvPluginSetup::ProcessKey(eKeys Key) eOSState cIptvPluginSetup::ProcessKey(eKeys keyP)
{ {
int oldsectionFiltering = sectionFiltering; int oldsectionFiltering = sectionFilteringM;
int oldNumDisabledFilters = numDisabledFilters; int oldNumDisabledFilters = numDisabledFiltersM;
eOSState state = cMenuSetupPage::ProcessKey(Key); eOSState state = cMenuSetupPage::ProcessKey(keyP);
if (state == osUnknown) { if (state == osUnknown) {
switch (Key) { switch (keyP) {
case kBlue: return ShowInfo(); case kBlue: return ShowInfo();
case kInfo: if (Current() < help.Size()) case kInfo: if (Current() < helpM.Size())
return AddSubMenu(new cMenuText(cString::sprintf("%s - %s '%s'", tr("Help"), trVDR("Plugin"), PLUGIN_NAME_I18N), help[Current()])); return AddSubMenu(new cMenuText(cString::sprintf("%s - %s '%s'", tr("Help"), trVDR("Plugin"), PLUGIN_NAME_I18N), helpM[Current()]));
default: state = osContinue; break; default: state = osContinue; break;
} }
} }
if ((Key != kNone) && ((numDisabledFilters != oldNumDisabledFilters) || (sectionFiltering != oldsectionFiltering))) { if ((keyP != kNone) && ((numDisabledFiltersM != oldNumDisabledFilters) || (sectionFilteringM != oldsectionFiltering))) {
while ((numDisabledFilters < oldNumDisabledFilters) && (oldNumDisabledFilters > 0)) while ((numDisabledFiltersM < oldNumDisabledFilters) && (oldNumDisabledFilters > 0))
disabledFilterIndexes[--oldNumDisabledFilters] = -1; disabledFilterIndexesM[--oldNumDisabledFilters] = -1;
Setup(); Setup();
} }
return state; return state;
} }
void cIptvPluginSetup::StoreFilters(const char *Name, int *Values) void cIptvPluginSetup::StoreFilters(const char *nameP, int *valuesP)
{ {
char buffer[SECTION_FILTER_TABLE_SIZE * 4]; char buffer[SECTION_FILTER_TABLE_SIZE * 4];
char *q = buffer; char *q = buffer;
for (int i = 0; i < SECTION_FILTER_TABLE_SIZE; ++i) { for (int i = 0; i < SECTION_FILTER_TABLE_SIZE; ++i) {
char s[3]; char s[3];
if (Values[i] < 0) if (valuesP[i] < 0)
break; break;
if (q > buffer) if (q > buffer)
*q++ = ' '; *q++ = ' ';
snprintf(s, sizeof(s), "%d", Values[i]); snprintf(s, sizeof(s), "%d", valuesP[i]);
strncpy(q, s, strlen(s)); strncpy(q, s, strlen(s));
q += strlen(s); q += strlen(s);
} }
*q = 0; *q = 0;
debug("cIptvPluginSetup::StoreFilters(): %s=%s\n", Name, buffer); debug("cIptvPluginSetup::StoreFilters(): %s=%s\n", nameP, buffer);
SetupStore(Name, buffer); SetupStore(nameP, buffer);
} }
void cIptvPluginSetup::Store(void) void cIptvPluginSetup::Store(void)
{ {
// Store values into setup.conf // Store values into setup.conf
SetupStore("TsBufferSize", tsBufferSize); SetupStore("TsBufferSize", tsBufferSizeM);
SetupStore("TsBufferPrefill", tsBufferPrefill); SetupStore("TsBufferPrefill", tsBufferPrefillM);
SetupStore("ExtProtocolBasePort", extProtocolBasePort); SetupStore("ExtProtocolBasePort", extProtocolBasePortM);
SetupStore("SectionFiltering", sectionFiltering); SetupStore("SectionFiltering", sectionFilteringM);
StoreFilters("DisabledFilters", disabledFilterIndexes); StoreFilters("DisabledFilters", disabledFilterIndexesM);
// Update global config // Update global config
IptvConfig.SetTsBufferSize(tsBufferSize); IptvConfig.SetTsBufferSize(tsBufferSizeM);
IptvConfig.SetTsBufferPrefillRatio(tsBufferPrefill); IptvConfig.SetTsBufferPrefillRatio(tsBufferPrefillM);
IptvConfig.SetExtProtocolBasePort(extProtocolBasePort); IptvConfig.SetExtProtocolBasePort(extProtocolBasePortM);
IptvConfig.SetSectionFiltering(sectionFiltering); IptvConfig.SetSectionFiltering(sectionFilteringM);
for (int i = 0; i < SECTION_FILTER_TABLE_SIZE; ++i) for (int i = 0; i < SECTION_FILTER_TABLE_SIZE; ++i)
IptvConfig.SetDisabledFilters(i, disabledFilterIndexes[i]); IptvConfig.SetDisabledFilters(i, disabledFilterIndexesM[i]);
} }

66
setup.h
View File

@ -12,70 +12,24 @@
#include <vdr/sourceparams.h> #include <vdr/sourceparams.h>
#include "common.h" #include "common.h"
class cIptvTransponderParameters
{
friend class cIptvSourceParam;
private:
int sidscan;
int pidscan;
int protocol;
char address[NAME_MAX];
int parameter;
public:
cIptvTransponderParameters(const char *Parameters = NULL);
int SidScan(void) const { return sidscan; }
int PidScan(void) const { return pidscan; }
int Protocol(void) const { return protocol; }
const char *Address(void) const { return address; }
int Parameter(void) const { return parameter; }
void SetSidScan(int SidScan) { sidscan = SidScan; }
void SetPidScan(int PidScan) { pidscan = PidScan; }
void SetProtocol(int Protocol) { protocol = Protocol; }
void SetAddress(const char *Address) { strncpy(address, Address, sizeof(address)); }
void SetParameter(int Parameter) { parameter = Parameter; }
cString ToString(char Type) const;
bool Parse(const char *s);
};
class cIptvSourceParam : public cSourceParam
{
private:
enum {
eProtocolUDP,
eProtocolHTTP,
eProtocolFILE,
eProtocolEXT,
eProtocolCount
};
int param;
cChannel data;
cIptvTransponderParameters itp;
const char *protocols[eProtocolCount];
public:
cIptvSourceParam(char Source, const char *Description);
virtual void SetData(cChannel *Channel);
virtual void GetData(cChannel *Channel);
virtual cOsdItem *GetOsdItem(void);
};
class cIptvPluginSetup : public cMenuSetupPage class cIptvPluginSetup : public cMenuSetupPage
{ {
private: private:
int tsBufferSize; int tsBufferSizeM;
int tsBufferPrefill; int tsBufferPrefillM;
int extProtocolBasePort; int extProtocolBasePortM;
int sectionFiltering; int sectionFilteringM;
int numDisabledFilters; int numDisabledFiltersM;
int disabledFilterIndexes[SECTION_FILTER_TABLE_SIZE]; int disabledFilterIndexesM[SECTION_FILTER_TABLE_SIZE];
const char *disabledFilterNames[SECTION_FILTER_TABLE_SIZE]; const char *disabledFilterNamesM[SECTION_FILTER_TABLE_SIZE];
cVector<const char*> help; cVector<const char*> helpM;
eOSState ShowInfo(void); eOSState ShowInfo(void);
void Setup(void); void Setup(void);
void StoreFilters(const char *Name, int *Values); void StoreFilters(const char *nameP, int *valuesP);
protected: protected:
virtual eOSState ProcessKey(eKeys Key); virtual eOSState ProcessKey(eKeys keyP);
virtual void Store(void); virtual void Store(void);
public: public:

58
sidscanner.c
View File

@ -11,10 +11,10 @@
#include "sidscanner.h" #include "sidscanner.h"
cSidScanner::cSidScanner(void) cSidScanner::cSidScanner(void)
: channelId(tChannelID::InvalidID), : channelIdM(tChannelID::InvalidID),
sidFound(false), sidFoundM(false),
nidFound(false), nidFoundM(false),
tidFound(false) tidFoundM(false)
{ {
debug("cSidScanner::cSidScanner()\n"); debug("cSidScanner::cSidScanner()\n");
Set(0x00, 0x00); // PAT Set(0x00, 0x00); // PAT
@ -26,75 +26,75 @@ cSidScanner::~cSidScanner()
debug("cSidScanner::~cSidScanner()\n"); debug("cSidScanner::~cSidScanner()\n");
} }
void cSidScanner::SetStatus(bool On) void cSidScanner::SetStatus(bool onP)
{ {
debug("cSidScanner::SetStatus(): %d\n", On); debug("cSidScanner::SetStatus(%d)\n", onP);
cFilter::SetStatus(On); cFilter::SetStatus(onP);
} }
void cSidScanner::SetChannel(const tChannelID &ChannelId) void cSidScanner::SetChannel(const tChannelID &channelIdP)
{ {
debug("cSidScanner::SetChannel(): %s\n", *ChannelId.ToString()); debug("cSidScanner::SetChannel('%s')\n", *channelIdP.ToString());
channelId = ChannelId; channelIdM = channelIdP;
sidFound = false; sidFoundM = false;
nidFound = false; nidFoundM = false;
tidFound = false; tidFoundM = false;
} }
void cSidScanner::Process(u_short Pid, u_char Tid, const u_char *Data, int Length) void cSidScanner::Process(u_short pidP, u_char tidP, const u_char *dataP, int lengthP)
{ {
int newSid = -1, newNid = -1, newTid = -1; int newSid = -1, newNid = -1, newTid = -1;
//debug("cSidScanner::Process()\n"); //debug("cSidScanner::Process()\n");
if (channelId.Valid()) { if (channelIdM.Valid()) {
if ((Pid == 0x00) && (Tid == 0x00)) { if ((pidP == 0x00) && (tidP == 0x00)) {
debug("cSidScanner::Process(): Pid=%d Tid=%02X\n", Pid, Tid); debug("cSidScanner::Process(): Pid=%d Tid=%02X\n", pidP, tidP);
SI::PAT pat(Data, false); SI::PAT pat(dataP, false);
if (!pat.CheckCRCAndParse()) if (!pat.CheckCRCAndParse())
return; return;
SI::PAT::Association assoc; SI::PAT::Association assoc;
for (SI::Loop::Iterator it; pat.associationLoop.getNext(assoc, it); ) { for (SI::Loop::Iterator it; pat.associationLoop.getNext(assoc, it); ) {
if (!assoc.isNITPid()) { if (!assoc.isNITPid()) {
if (assoc.getServiceId() != channelId.Sid()) { if (assoc.getServiceId() != channelIdM.Sid()) {
debug("cSidScanner::Process(): Sid=%d\n", assoc.getServiceId()); debug("cSidScanner::Process(): Sid=%d\n", assoc.getServiceId());
newSid = assoc.getServiceId(); newSid = assoc.getServiceId();
} }
sidFound = true; sidFoundM = true;
break; break;
} }
} }
} }
else if ((Pid == 0x10) && (Tid == 0x40)) { else if ((pidP == 0x10) && (tidP == 0x40)) {
debug("cSidScanner::Process(): Pid=%d Tid=%02X\n", Pid, Tid); debug("cSidScanner::Process(): Pid=%d Tid=%02X\n", pidP, tidP);
SI::NIT nit(Data, false); SI::NIT nit(dataP, false);
if (!nit.CheckCRCAndParse()) if (!nit.CheckCRCAndParse())
return; return;
SI::NIT::TransportStream ts; SI::NIT::TransportStream ts;
for (SI::Loop::Iterator it; nit.transportStreamLoop.getNext(ts, it); ) { for (SI::Loop::Iterator it; nit.transportStreamLoop.getNext(ts, it); ) {
if (ts.getTransportStreamId() != channelId.Tid()) { if (ts.getTransportStreamId() != channelIdM.Tid()) {
debug("cSidScanner::Process(): TSid=%d\n", ts.getTransportStreamId()); debug("cSidScanner::Process(): TSid=%d\n", ts.getTransportStreamId());
newTid = ts.getTransportStreamId(); newTid = ts.getTransportStreamId();
} }
tidFound = true; tidFoundM = true;
break; // default to the first one break; // default to the first one
} }
if (nit.getNetworkId() != channelId.Nid()) { if (nit.getNetworkId() != channelIdM.Nid()) {
debug("cSidScanner::Process(): Nid=%d\n", ts.getTransportStreamId()); debug("cSidScanner::Process(): Nid=%d\n", ts.getTransportStreamId());
newNid = nit.getNetworkId(); newNid = nit.getNetworkId();
} }
nidFound = true; nidFoundM = true;
} }
} }
if ((newSid >= 0) || (newNid >= 0) || (newTid >= 0)) { if ((newSid >= 0) || (newNid >= 0) || (newTid >= 0)) {
if (!Channels.Lock(true, 10)) if (!Channels.Lock(true, 10))
return; return;
cChannel *IptvChannel = Channels.GetByChannelID(channelId); cChannel *IptvChannel = Channels.GetByChannelID(channelIdM);
if (IptvChannel) if (IptvChannel)
IptvChannel->SetId((newNid < 0) ? IptvChannel->Nid() : newNid, (newTid < 0) ? IptvChannel->Tid() : newTid, IptvChannel->SetId((newNid < 0) ? IptvChannel->Nid() : newNid, (newTid < 0) ? IptvChannel->Tid() : newTid,
(newSid < 0) ? IptvChannel->Sid() : newSid, IptvChannel->Rid()); (newSid < 0) ? IptvChannel->Sid() : newSid, IptvChannel->Rid());
Channels.Unlock(); Channels.Unlock();
} }
if (sidFound && nidFound && tidFound) { if (sidFoundM && nidFoundM && tidFoundM) {
SetChannel(tChannelID::InvalidID); SetChannel(tChannelID::InvalidID);
SetStatus(false); SetStatus(false);
} }

14
sidscanner.h
View File

@ -13,19 +13,19 @@
class cSidScanner : public cFilter { class cSidScanner : public cFilter {
private: private:
tChannelID channelId; tChannelID channelIdM;
bool sidFound; bool sidFoundM;
bool nidFound; bool nidFoundM;
bool tidFound; bool tidFoundM;
protected: protected:
virtual void Process(u_short Pid, u_char Tid, const u_char *Data, int Length); virtual void Process(u_short pidP, u_char tidP, const u_char *dataP, int lengthP);
virtual void SetStatus(bool On); virtual void SetStatus(bool onP);
public: public:
cSidScanner(void); cSidScanner(void);
~cSidScanner(); ~cSidScanner();
void SetChannel(const tChannelID &ChannelId); void SetChannel(const tChannelID &channelIdP);
void Open() { SetStatus(true); } void Open() { SetStatus(true); }
void Close() { SetStatus(false); } void Close() { SetStatus(false); }
}; };

122
source.c
View File

@ -10,25 +10,25 @@
// --- cIptvTransponderParameters -------------------------------------------- // --- cIptvTransponderParameters --------------------------------------------
cIptvTransponderParameters::cIptvTransponderParameters(const char *Parameters) cIptvTransponderParameters::cIptvTransponderParameters(const char *parametersP)
: sidscan(0), : sidScanM(0),
pidscan(0), pidScanM(0),
protocol(eProtocolUDP), protocolM(eProtocolUDP),
parameter(0) parameterM(0)
{ {
debug("cIptvTransponderParameters::cIptvTransponderParameters(): Parameters=%s\n", Parameters); debug("cIptvTransponderParameters::cIptvTransponderParameters('%s')\n", parametersP);
memset(&address, 0, sizeof(address)); memset(&addressM, 0, sizeof(addressM));
Parse(Parameters); Parse(parametersP);
} }
cString cIptvTransponderParameters::ToString(char Type) const cString cIptvTransponderParameters::ToString(char typeP) const
{ {
debug("cIptvTransponderParameters::ToString() Type=%c\n", Type); debug("cIptvTransponderParameters::ToString(%c)\n", typeP);
const char *protocolstr; const char *protocolstr;
switch (protocol) { switch (protocolM) {
case eProtocolEXT: case eProtocolEXT:
protocolstr = "EXT"; protocolstr = "EXT";
break; break;
@ -46,17 +46,17 @@ cString cIptvTransponderParameters::ToString(char Type) const
protocolstr = "UDP"; protocolstr = "UDP";
break; break;
} }
return cString::sprintf("S=%d|P=%d|F=%s|U=%s|A=%d", sidscan, pidscan, protocolstr, address, parameter); return cString::sprintf("S=%d|P=%d|F=%s|U=%s|A=%d", sidScanM, pidScanM, protocolstr, addressM, parameterM);
} }
bool cIptvTransponderParameters::Parse(const char *s) bool cIptvTransponderParameters::Parse(const char *strP)
{ {
debug("cIptvTransponderParameters::Parse(): s=%s\n", s); debug("cIptvTransponderParameters::Parse('%s'\n", strP);
bool result = false; bool result = false;
if (s && *s) { if (strP && *strP) {
const char *delim = "|"; const char *delim = "|";
char *str = strdup(s); char *str = strdup(strP);
char *saveptr = NULL; char *saveptr = NULL;
char *token = NULL; char *token = NULL;
bool found_s = false; bool found_s = false;
@ -72,41 +72,41 @@ bool cIptvTransponderParameters::Parse(const char *s)
++data; ++data;
switch (*token) { switch (*token) {
case 'S': case 'S':
sidscan = (int)strtol(data, (char **)NULL, 10); sidScanM = (int)strtol(data, (char **)NULL, 10);
found_s = true; found_s = true;
break; break;
case 'P': case 'P':
pidscan = (int)strtol(data, (char **)NULL, 10); pidScanM = (int)strtol(data, (char **)NULL, 10);
found_p = true; found_p = true;
break; break;
case 'F': case 'F':
if (strstr(data, "UDP")) { if (strstr(data, "UDP")) {
protocol = eProtocolUDP; protocolM = eProtocolUDP;
found_f = true; found_f = true;
} }
else if (strstr(data, "CURL")) { else if (strstr(data, "CURL")) {
protocol = eProtocolCURL; protocolM = eProtocolCURL;
found_f = true; found_f = true;
} }
else if (strstr(data, "HTTP")) { else if (strstr(data, "HTTP")) {
protocol = eProtocolHTTP; protocolM = eProtocolHTTP;
found_f = true; found_f = true;
} }
else if (strstr(data, "FILE")) { else if (strstr(data, "FILE")) {
protocol = eProtocolFILE; protocolM = eProtocolFILE;
found_f = true; found_f = true;
} }
else if (strstr(data, "EXT")) { else if (strstr(data, "EXT")) {
protocol = eProtocolEXT; protocolM = eProtocolEXT;
found_f = true; found_f = true;
} }
break; break;
case 'U': case 'U':
strn0cpy(address, data, sizeof(address)); strn0cpy(addressM, data, sizeof(addressM));
found_u = true; found_u = true;
break; break;
case 'A': case 'A':
parameter = (int)strtol(data, (char **)NULL, 10); parameterM = (int)strtol(data, (char **)NULL, 10);
found_a = true; found_a = true;
break; break;
default: default:
@ -129,55 +129,55 @@ bool cIptvTransponderParameters::Parse(const char *s)
// --- cIptvSourceParam ------------------------------------------------------ // --- cIptvSourceParam ------------------------------------------------------
cIptvSourceParam::cIptvSourceParam(char Source, const char *Description) cIptvSourceParam::cIptvSourceParam(char sourceP, const char *descriptionP)
: cSourceParam(Source, Description), : cSourceParam(sourceP, descriptionP),
param(0), paramM(0),
nid(0), nidM(0),
tid(0), tidM(0),
rid(0), ridM(0),
data(), dataM(),
itp() itpM()
{ {
debug("cIptvSourceParam::cIptvSourceParam(): Source=%c Description=%s\n", Source, Description); debug("cIptvSourceParam::cIptvSourceParam(%c, '%s')\n", sourceP, descriptionP);
protocols[cIptvTransponderParameters::eProtocolUDP] = tr("UDP"); protocolsM[cIptvTransponderParameters::eProtocolUDP] = tr("UDP");
protocols[cIptvTransponderParameters::eProtocolCURL] = tr("CURL"); protocolsM[cIptvTransponderParameters::eProtocolCURL] = tr("CURL");
protocols[cIptvTransponderParameters::eProtocolHTTP] = tr("HTTP"); protocolsM[cIptvTransponderParameters::eProtocolHTTP] = tr("HTTP");
protocols[cIptvTransponderParameters::eProtocolFILE] = tr("FILE"); protocolsM[cIptvTransponderParameters::eProtocolFILE] = tr("FILE");
protocols[cIptvTransponderParameters::eProtocolEXT] = tr("EXT"); protocolsM[cIptvTransponderParameters::eProtocolEXT] = tr("EXT");
} }
void cIptvSourceParam::SetData(cChannel *Channel) void cIptvSourceParam::SetData(cChannel *channelP)
{ {
debug("cIptvSourceParam::SetData(): Channel=%s)\n", Channel->Parameters()); debug("cIptvSourceParam::SetData('%s')\n", channelP->Parameters());
data = *Channel; dataM = *channelP;
nid = data.Nid(); nidM = dataM.Nid();
tid = data.Tid(); tidM = dataM.Tid();
rid = data.Rid(); ridM = dataM.Rid();
itp.Parse(data.Parameters()); itpM.Parse(dataM.Parameters());
param = 0; paramM = 0;
} }
void cIptvSourceParam::GetData(cChannel *Channel) void cIptvSourceParam::GetData(cChannel *channelP)
{ {
debug("cIptvSourceParam::GetData(): Channel=%s\n", Channel->Parameters()); debug("cIptvSourceParam::GetData('%s')\n", channelP->Parameters());
data.SetTransponderData(Channel->Source(), Channel->Frequency(), data.Srate(), itp.ToString(Source()), true); dataM.SetTransponderData(channelP->Source(), channelP->Frequency(), dataM.Srate(), itpM.ToString(Source()), true);
data.SetId(nid, tid, Channel->Sid(), rid); dataM.SetId(nidM, tidM, channelP->Sid(), ridM);
*Channel = data; *channelP = dataM;
} }
cOsdItem *cIptvSourceParam::GetOsdItem(void) cOsdItem *cIptvSourceParam::GetOsdItem(void)
{ {
debug("cIptvSourceParam::GetOsdItem()\n"); debug("cIptvSourceParam::GetOsdItem()\n");
switch (param++) { switch (paramM++) {
case 0: return new cMenuEditIntItem( tr("Nid"), &nid, 0); case 0: return new cMenuEditIntItem( tr("Nid"), &nidM, 0);
case 1: return new cMenuEditIntItem( tr("Tid"), &tid, 0); case 1: return new cMenuEditIntItem( tr("Tid"), &tidM, 0);
case 2: return new cMenuEditIntItem( tr("Rid"), &rid, 0); case 2: return new cMenuEditIntItem( tr("Rid"), &ridM, 0);
case 3: return new cMenuEditBoolItem(tr("Scan section ids"), &itp.sidscan); case 3: return new cMenuEditBoolItem(tr("Scan section ids"), &itpM.sidScanM);
case 4: return new cMenuEditBoolItem(tr("Scan pids"), &itp.pidscan); case 4: return new cMenuEditBoolItem(tr("Scan pids"), &itpM.pidScanM);
case 5: return new cMenuEditStraItem(tr("Protocol"), &itp.protocol, ELEMENTS(protocols), protocols); case 5: return new cMenuEditStraItem(tr("Protocol"), &itpM.protocolM, ELEMENTS(protocolsM), protocolsM);
case 6: return new cMenuEditStrItem( tr("Address"), itp.address, sizeof(itp.address)); case 6: return new cMenuEditStrItem( tr("Address"), itpM.addressM, sizeof(itpM.addressM));
case 7: return new cMenuEditIntItem( tr("Parameter"), &itp.parameter, 0, 0xFFFF); case 7: return new cMenuEditIntItem( tr("Parameter"), &itpM.parameterM, 0, 0xFFFF);
default: return NULL; default: return NULL;
} }
return NULL; return NULL;

56
source.h
View File

@ -17,11 +17,11 @@ class cIptvTransponderParameters
friend class cIptvSourceParam; friend class cIptvSourceParam;
private: private:
int sidscan; int sidScanM;
int pidscan; int pidScanM;
int protocol; int protocolM;
char address[NAME_MAX]; char addressM[NAME_MAX];
int parameter; int parameterM;
public: public:
enum { enum {
@ -32,36 +32,36 @@ public:
eProtocolEXT, eProtocolEXT,
eProtocolCount eProtocolCount
}; };
cIptvTransponderParameters(const char *Parameters = NULL); cIptvTransponderParameters(const char *parametersP = NULL);
int SidScan(void) const { return sidscan; } int SidScan(void) const { return sidScanM; }
int PidScan(void) const { return pidscan; } int PidScan(void) const { return pidScanM; }
int Protocol(void) const { return protocol; } int Protocol(void) const { return protocolM; }
const char *Address(void) const { return address; } const char *Address(void) const { return addressM; }
int Parameter(void) const { return parameter; } int Parameter(void) const { return parameterM; }
void SetSidScan(int SidScan) { sidscan = SidScan; } void SetSidScan(int sidScanP) { sidScanM = sidScanP; }
void SetPidScan(int PidScan) { pidscan = PidScan; } void SetPidScan(int pidScanP) { pidScanM = pidScanP; }
void SetProtocol(int Protocol) { protocol = Protocol; } void SetProtocol(int protocolP) { protocolM = protocolP; }
void SetAddress(const char *Address) { strncpy(address, Address, sizeof(address)); } void SetAddress(const char *addressP) { strncpy(addressM, addressP, sizeof(addressM)); }
void SetParameter(int Parameter) { parameter = Parameter; } void SetParameter(int parameterP) { parameterM = parameterP; }
cString ToString(char Type) const; cString ToString(char typeP) const;
bool Parse(const char *s); bool Parse(const char *strP);
}; };
class cIptvSourceParam : public cSourceParam class cIptvSourceParam : public cSourceParam
{ {
private: private:
int param; int paramM;
int nid; int nidM;
int tid; int tidM;
int rid; int ridM;
cChannel data; cChannel dataM;
cIptvTransponderParameters itp; cIptvTransponderParameters itpM;
const char *protocols[cIptvTransponderParameters::eProtocolCount]; const char *protocolsM[cIptvTransponderParameters::eProtocolCount];
public: public:
cIptvSourceParam(char Source, const char *Description); cIptvSourceParam(char sourceP, const char *descriptionP);
virtual void SetData(cChannel *Channel); virtual void SetData(cChannel *channelP);
virtual void GetData(cChannel *Channel); virtual void GetData(cChannel *channelP);
virtual cOsdItem *GetOsdItem(void); virtual cOsdItem *GetOsdItem(void);
}; };

140
statistics.c
View File

@ -13,10 +13,10 @@
// Section statistic class // Section statistic class
cIptvSectionStatistics::cIptvSectionStatistics() cIptvSectionStatistics::cIptvSectionStatistics()
: filteredData(0), : filteredDataM(0),
numberOfCalls(0), numberOfCallsM(0),
timer(), timerM(),
mutex() mutexM()
{ {
//debug("cIptvSectionStatistics::cIptvSectionStatistics()\n"); //debug("cIptvSectionStatistics::cIptvSectionStatistics()\n");
} }
@ -29,36 +29,36 @@ cIptvSectionStatistics::~cIptvSectionStatistics()
cString cIptvSectionStatistics::GetSectionStatistic() cString cIptvSectionStatistics::GetSectionStatistic()
{ {
//debug("cIptvSectionStatistics::GetStatistic()\n"); //debug("cIptvSectionStatistics::GetStatistic()\n");
cMutexLock MutexLock(&mutex); cMutexLock MutexLock(&mutexM);
uint64_t elapsed = timer.Elapsed(); /* in milliseconds */ uint64_t elapsed = timerM.Elapsed(); /* in milliseconds */
timer.Set(); timerM.Set();
long bitrate = elapsed ? (long)(1000.0L * filteredData / KILOBYTE(1) / elapsed) : 0L; long bitrate = elapsed ? (long)(1000.0L * filteredDataM / KILOBYTE(1) / elapsed) : 0L;
if (!IptvConfig.GetUseBytes()) if (!IptvConfig.GetUseBytes())
bitrate *= 8; bitrate *= 8;
// no trailing linefeed here! // no trailing linefeed here!
cString s = cString::sprintf("%4ld (%4ld k%s/s)", numberOfCalls, bitrate, cString s = cString::sprintf("%4ld (%4ld k%s/s)", numberOfCallsM, bitrate,
IptvConfig.GetUseBytes() ? "B" : "bit"); IptvConfig.GetUseBytes() ? "B" : "bit");
filteredData = numberOfCalls = 0; filteredDataM = numberOfCallsM = 0;
return s; return s;
} }
void cIptvSectionStatistics::AddSectionStatistic(long Bytes, long Calls) void cIptvSectionStatistics::AddSectionStatistic(long bytesP, long callsP)
{ {
//debug("cIptvSectionStatistics::AddStatistic(Bytes=%ld, Calls=%ld)\n", Bytes, Calls); //debug("cIptvSectionStatistics::AddStatistic(%ld, %ld)\n", bytesP, callsP);
cMutexLock MutexLock(&mutex); cMutexLock MutexLock(&mutexM);
filteredData += Bytes; filteredDataM += bytesP;
numberOfCalls += Calls; numberOfCallsM += callsP;
} }
// --- cIptvPidStatistics ---------------------------------------------------- // --- cIptvPidStatistics ----------------------------------------------------
// Device statistic class // Device statistic class
cIptvPidStatistics::cIptvPidStatistics() cIptvPidStatistics::cIptvPidStatistics()
: timer(), : timerM(),
mutex() mutexM()
{ {
debug("cIptvPidStatistics::cIptvPidStatistics()\n"); debug("cIptvPidStatistics::cIptvPidStatistics()\n");
memset(mostActivePids, '\0', sizeof(mostActivePids)); memset(mostActivePidsM, '\0', sizeof(mostActivePidsM));
} }
cIptvPidStatistics::~cIptvPidStatistics() cIptvPidStatistics::~cIptvPidStatistics()
@ -69,29 +69,29 @@ cIptvPidStatistics::~cIptvPidStatistics()
cString cIptvPidStatistics::GetPidStatistic() cString cIptvPidStatistics::GetPidStatistic()
{ {
//debug("cIptvPidStatistics::GetStatistic()\n"); //debug("cIptvPidStatistics::GetStatistic()\n");
cMutexLock MutexLock(&mutex); cMutexLock MutexLock(&mutexM);
uint64_t elapsed = timer.Elapsed(); /* in milliseconds */ uint64_t elapsed = timerM.Elapsed(); /* in milliseconds */
timer.Set(); timerM.Set();
cString s("Active pids:\n"); cString s("Active pids:\n");
for (unsigned int i = 0; i < IPTV_STATS_ACTIVE_PIDS_COUNT; ++i) { for (unsigned int i = 0; i < IPTV_STATS_ACTIVE_PIDS_COUNT; ++i) {
if (mostActivePids[i].pid) { if (mostActivePidsM[i].pid) {
long bitrate = elapsed ? (long)(1000.0L * mostActivePids[i].DataAmount / KILOBYTE(1) / elapsed) : 0L; long bitrate = elapsed ? (long)(1000.0L * mostActivePidsM[i].DataAmount / KILOBYTE(1) / elapsed) : 0L;
if (!IptvConfig.GetUseBytes()) if (!IptvConfig.GetUseBytes())
bitrate *= 8; bitrate *= 8;
s = cString::sprintf("%sPid %d: %4d (%4ld k%s/s)\n", *s, i, s = cString::sprintf("%sPid %d: %4d (%4ld k%s/s)\n", *s, i,
mostActivePids[i].pid, bitrate, mostActivePidsM[i].pid, bitrate,
IptvConfig.GetUseBytes() ? "B" : "bit"); IptvConfig.GetUseBytes() ? "B" : "bit");
} }
} }
memset(mostActivePids, '\0', sizeof(mostActivePids)); memset(mostActivePidsM, '\0', sizeof(mostActivePidsM));
return s; return s;
} }
int cIptvPidStatistics::SortPids(const void* data1, const void* data2) int cIptvPidStatistics::SortPids(const void* data1P, const void* data2P)
{ {
//debug("cIptvPidStatistics::SortPids()\n"); //debug("cIptvPidStatistics::SortPids()\n");
const pidStruct *comp1 = reinterpret_cast<const pidStruct*>(data1); const pidStruct *comp1 = reinterpret_cast<const pidStruct*>(data1P);
const pidStruct *comp2 = reinterpret_cast<const pidStruct*>(data2); const pidStruct *comp2 = reinterpret_cast<const pidStruct*>(data2P);
if (comp1->DataAmount > comp2->DataAmount) if (comp1->DataAmount > comp2->DataAmount)
return -1; return -1;
if (comp1->DataAmount < comp2->DataAmount) if (comp1->DataAmount < comp2->DataAmount)
@ -99,27 +99,27 @@ int cIptvPidStatistics::SortPids(const void* data1, const void* data2)
return 0; return 0;
} }
void cIptvPidStatistics::AddPidStatistic(u_short Pid, long Payload) void cIptvPidStatistics::AddPidStatistic(u_short pidP, long payloadP)
{ {
//debug("cIptvPidStatistics::AddStatistic(pid=%ld, payload=%ld)\n", Pid, Payload); //debug("cIptvPidStatistics::AddStatistic(%ld, %ld)\n", pidP, payloadP);
cMutexLock MutexLock(&mutex); cMutexLock MutexLock(&mutexM);
const int numberOfElements = sizeof(mostActivePids) / sizeof(pidStruct); const int numberOfElements = sizeof(mostActivePidsM) / sizeof(pidStruct);
// If our statistic already is in the array, update it and quit // If our statistic already is in the array, update it and quit
for (int i = 0; i < numberOfElements; ++i) { for (int i = 0; i < numberOfElements; ++i) {
if (mostActivePids[i].pid == Pid) { if (mostActivePidsM[i].pid == pidP) {
mostActivePids[i].DataAmount += Payload; mostActivePidsM[i].DataAmount += payloadP;
// Now re-sort the array and quit // Now re-sort the array and quit
qsort(mostActivePids, numberOfElements, sizeof(pidStruct), SortPids); qsort(mostActivePidsM, numberOfElements, sizeof(pidStruct), SortPids);
return; return;
} }
} }
// Apparently our pid isn't in the array. Replace the last element with this // Apparently our pid isn't in the array. Replace the last element with this
// one if new payload is greater // one if new payload is greater
if (mostActivePids[numberOfElements - 1].DataAmount < Payload) { if (mostActivePidsM[numberOfElements - 1].DataAmount < payloadP) {
mostActivePids[numberOfElements - 1].pid = Pid; mostActivePidsM[numberOfElements - 1].pid = pidP;
mostActivePids[numberOfElements - 1].DataAmount = Payload; mostActivePidsM[numberOfElements - 1].DataAmount = payloadP;
// Re-sort // Re-sort
qsort(mostActivePids, numberOfElements, sizeof(pidStruct), SortPids); qsort(mostActivePidsM, numberOfElements, sizeof(pidStruct), SortPids);
} }
} }
@ -127,9 +127,9 @@ void cIptvPidStatistics::AddPidStatistic(u_short Pid, long Payload)
// Streamer statistic class // Streamer statistic class
cIptvStreamerStatistics::cIptvStreamerStatistics() cIptvStreamerStatistics::cIptvStreamerStatistics()
: dataBytes(0), : dataBytesM(0),
timer(), timerM(),
mutex() mutexM()
{ {
debug("cIptvStreamerStatistics::cIptvStreamerStatistics()\n"); debug("cIptvStreamerStatistics::cIptvStreamerStatistics()\n");
} }
@ -142,32 +142,32 @@ cIptvStreamerStatistics::~cIptvStreamerStatistics()
cString cIptvStreamerStatistics::GetStreamerStatistic() cString cIptvStreamerStatistics::GetStreamerStatistic()
{ {
//debug("cIptvStreamerStatistics::GetStatistic()\n"); //debug("cIptvStreamerStatistics::GetStatistic()\n");
cMutexLock MutexLock(&mutex); cMutexLock MutexLock(&mutexM);
uint64_t elapsed = timer.Elapsed(); /* in milliseconds */ uint64_t elapsed = timerM.Elapsed(); /* in milliseconds */
timer.Set(); timerM.Set();
long bitrate = elapsed ? (long)(1000.0L * dataBytes / KILOBYTE(1) / elapsed) : 0L; long bitrate = elapsed ? (long)(1000.0L * dataBytesM / KILOBYTE(1) / elapsed) : 0L;
if (!IptvConfig.GetUseBytes()) if (!IptvConfig.GetUseBytes())
bitrate *= 8; bitrate *= 8;
cString s = cString::sprintf("%ld k%s/s", bitrate, IptvConfig.GetUseBytes() ? "B" : "bit"); cString s = cString::sprintf("%ld k%s/s", bitrate, IptvConfig.GetUseBytes() ? "B" : "bit");
dataBytes = 0; dataBytesM = 0;
return s; return s;
} }
void cIptvStreamerStatistics::AddStreamerStatistic(long Bytes) void cIptvStreamerStatistics::AddStreamerStatistic(long bytesP)
{ {
//debug("cIptvStreamerStatistics::AddStatistic(Bytes=%ld)\n", Bytes); //debug("cIptvStreamerStatistics::AddStatistic(%ld)\n", bytesP);
cMutexLock MutexLock(&mutex); cMutexLock MutexLock(&mutexM);
dataBytes += Bytes; dataBytesM += bytesP;
} }
// Buffer statistic class // Buffer statistic class
cIptvBufferStatistics::cIptvBufferStatistics() cIptvBufferStatistics::cIptvBufferStatistics()
: dataBytes(0), : dataBytesM(0),
freeSpace(0), freeSpaceM(0),
usedSpace(0), usedSpaceM(0),
timer(), timerM(),
mutex() mutexM()
{ {
debug("cIptvBufferStatistics::cIptvBufferStatistics()\n"); debug("cIptvBufferStatistics::cIptvBufferStatistics()\n");
} }
@ -180,14 +180,14 @@ cIptvBufferStatistics::~cIptvBufferStatistics()
cString cIptvBufferStatistics::GetBufferStatistic() cString cIptvBufferStatistics::GetBufferStatistic()
{ {
//debug("cIptvBufferStatistics::GetStatistic()\n"); //debug("cIptvBufferStatistics::GetStatistic()\n");
cMutexLock MutexLock(&mutex); cMutexLock MutexLock(&mutexM);
uint64_t elapsed = timer.Elapsed(); /* in milliseconds */ uint64_t elapsed = timerM.Elapsed(); /* in milliseconds */
timer.Set(); timerM.Set();
long bitrate = elapsed ? (long)(1000.0L * dataBytes / KILOBYTE(1) / elapsed) : 0L; long bitrate = elapsed ? (long)(1000.0L * dataBytesM / KILOBYTE(1) / elapsed) : 0L;
long totalSpace = MEGABYTE(IptvConfig.GetTsBufferSize()); long totalSpace = MEGABYTE(IptvConfig.GetTsBufferSize());
float percentage = (float)((float)usedSpace / (float)totalSpace * 100.0); float percentage = (float)((float)usedSpaceM / (float)totalSpace * 100.0);
long totalKilos = totalSpace / KILOBYTE(1); long totalKilos = totalSpace / KILOBYTE(1);
long usedKilos = usedSpace / KILOBYTE(1); long usedKilos = usedSpaceM / KILOBYTE(1);
if (!IptvConfig.GetUseBytes()) { if (!IptvConfig.GetUseBytes()) {
bitrate *= 8; bitrate *= 8;
totalKilos *= 8; totalKilos *= 8;
@ -196,16 +196,16 @@ cString cIptvBufferStatistics::GetBufferStatistic()
cString s = cString::sprintf("Buffer bitrate: %ld k%s/s\nBuffer usage: %ld/%ld k%s (%2.1f%%)\n", bitrate, cString s = cString::sprintf("Buffer bitrate: %ld k%s/s\nBuffer usage: %ld/%ld k%s (%2.1f%%)\n", bitrate,
IptvConfig.GetUseBytes() ? "B" : "bit", usedKilos, totalKilos, IptvConfig.GetUseBytes() ? "B" : "bit", usedKilos, totalKilos,
IptvConfig.GetUseBytes() ? "B" : "bit", percentage); IptvConfig.GetUseBytes() ? "B" : "bit", percentage);
dataBytes = 0; dataBytesM = 0;
usedSpace = 0; usedSpaceM = 0;
return s; return s;
} }
void cIptvBufferStatistics::AddBufferStatistic(long Bytes, long Used) void cIptvBufferStatistics::AddBufferStatistic(long bytesP, long usedP)
{ {
//debug("cIptvBufferStatistics::AddStatistic(Bytes=%ld, Used=%ld)\n", Bytes, Used); //debug("cIptvBufferStatistics::AddStatistic(%ld, %ld)\n", bytesP, usedP);
cMutexLock MutexLock(&mutex); cMutexLock MutexLock(&mutexM);
dataBytes += Bytes; dataBytesM += bytesP;
if (Used > usedSpace) if (usedP > usedSpaceM)
usedSpace = Used; usedSpaceM = usedP;
} }

40
statistics.h
View File

@ -18,13 +18,13 @@ public:
cString GetSectionStatistic(); cString GetSectionStatistic();
protected: protected:
void AddSectionStatistic(long Bytes, long Calls); void AddSectionStatistic(long bytesP, long callsP);
private: private:
long filteredData; long filteredDataM;
long numberOfCalls; long numberOfCallsM;
cTimeMs timer; cTimeMs timerM;
cMutex mutex; cMutex mutexM;
}; };
// Pid statistics // Pid statistics
@ -35,19 +35,19 @@ public:
cString GetPidStatistic(); cString GetPidStatistic();
protected: protected:
void AddPidStatistic(u_short Pid, long Payload); void AddPidStatistic(u_short pidP, long payloadP);
private: private:
struct pidStruct { struct pidStruct {
u_short pid; u_short pid;
long DataAmount; long DataAmount;
}; };
pidStruct mostActivePids[IPTV_STATS_ACTIVE_PIDS_COUNT]; pidStruct mostActivePidsM[IPTV_STATS_ACTIVE_PIDS_COUNT];
cTimeMs timer; cTimeMs timerM;
cMutex mutex; cMutex mutexM;
private: private:
static int SortPids(const void* data1, const void* data2); static int SortPids(const void* data1P, const void* data2P);
}; };
// Streamer statistics // Streamer statistics
@ -58,12 +58,12 @@ public:
cString GetStreamerStatistic(); cString GetStreamerStatistic();
protected: protected:
void AddStreamerStatistic(long Bytes); void AddStreamerStatistic(long bytesP);
private: private:
long dataBytes; long dataBytesM;
cTimeMs timer; cTimeMs timerM;
cMutex mutex; cMutex mutexM;
}; };
// Buffer statistics // Buffer statistics
@ -74,14 +74,14 @@ public:
cString GetBufferStatistic(); cString GetBufferStatistic();
protected: protected:
void AddBufferStatistic(long Bytes, long Used); void AddBufferStatistic(long bytesP, long usedP);
private: private:
long dataBytes; long dataBytesM;
long freeSpace; long freeSpaceM;
long usedSpace; long usedSpaceM;
cTimeMs timer; cTimeMs timerM;
cMutex mutex; cMutex mutexM;
}; };
#endif // __IPTV_STATISTICS_H #endif // __IPTV_STATISTICS_H

76
streamer.c
View File

@ -11,17 +11,17 @@
#include "common.h" #include "common.h"
#include "streamer.h" #include "streamer.h"
cIptvStreamer::cIptvStreamer(cRingBufferLinear* RingBuffer, unsigned int PacketLen) cIptvStreamer::cIptvStreamer(cRingBufferLinear* ringBufferP, unsigned int packetLenP)
: cThread("IPTV streamer"), : cThread("IPTV streamer"),
ringBuffer(RingBuffer), ringBufferM(ringBufferP),
packetBufferLen(PacketLen), packetBufferLenM(packetLenP),
protocol(NULL) protocolM(NULL)
{ {
debug("cIptvStreamer::cIptvStreamer(%d)\n", packetBufferLen); debug("cIptvStreamer::cIptvStreamer(%d)\n", packetBufferLenM);
// Allocate packet buffer // Allocate packet buffer
packetBuffer = MALLOC(unsigned char, packetBufferLen); packetBufferM = MALLOC(unsigned char, packetBufferLenM);
if (packetBuffer) if (packetBufferM)
memset(packetBuffer, 0, packetBufferLen); memset(packetBufferM, 0, packetBufferLenM);
else else
error("MALLOC() failed for packet buffer"); error("MALLOC() failed for packet buffer");
} }
@ -31,10 +31,10 @@ cIptvStreamer::~cIptvStreamer()
debug("cIptvStreamer::~cIptvStreamer()\n"); debug("cIptvStreamer::~cIptvStreamer()\n");
// Close the protocol // Close the protocol
Close(); Close();
protocol = NULL; protocolM = NULL;
ringBuffer = NULL; ringBufferM = NULL;
// Free allocated memory // Free allocated memory
free(packetBuffer); free(packetBufferM);
} }
void cIptvStreamer::Action(void) void cIptvStreamer::Action(void)
@ -43,20 +43,20 @@ void cIptvStreamer::Action(void)
// Increase priority // Increase priority
//SetPriority(-1); //SetPriority(-1);
// Do the thread loop // Do the thread loop
while (packetBuffer && Running()) { while (packetBufferM && Running()) {
int length = -1; int length = -1;
if (protocol) if (protocolM)
length = protocol->Read(packetBuffer, min((unsigned int)ringBuffer->Free(), packetBufferLen)); length = protocolM->Read(packetBufferM, min((unsigned int)ringBufferM->Free(), packetBufferLenM));
if (length > 0) { if (length > 0) {
AddStreamerStatistic(length); AddStreamerStatistic(length);
if (ringBuffer) { if (ringBufferM) {
int p = ringBuffer->Put(packetBuffer, length); int p = ringBufferM->Put(packetBufferM, length);
if (p != length) if (p != length)
ringBuffer->ReportOverflow(length - p); ringBufferM->ReportOverflow(length - p);
} }
} }
else else
sleep.Wait(10); // to avoid busy loop and reduce cpu load sleepM.Wait(10); // to avoid busy loop and reduce cpu load
} }
debug("cIptvStreamer::Action(): Exiting\n"); debug("cIptvStreamer::Action(): Exiting\n");
} }
@ -65,7 +65,7 @@ bool cIptvStreamer::Open(void)
{ {
debug("cIptvStreamer::Open()\n"); debug("cIptvStreamer::Open()\n");
// Open the protocol // Open the protocol
if (protocol && !protocol->Open()) if (protocolM && !protocolM->Open())
return false; return false;
// Start thread // Start thread
Start(); Start();
@ -76,31 +76,31 @@ bool cIptvStreamer::Close(void)
{ {
debug("cIptvStreamer::Close()\n"); debug("cIptvStreamer::Close()\n");
// Stop thread // Stop thread
sleep.Signal(); sleepM.Signal();
if (Running()) if (Running())
Cancel(3); Cancel(3);
// Close the protocol // Close the protocol
if (protocol) if (protocolM)
protocol->Close(); protocolM->Close();
return true; return true;
} }
bool cIptvStreamer::Set(const char* Location, const int Parameter, const int Index, cIptvProtocolIf* Protocol) bool cIptvStreamer::Set(const char* locationP, const int parameterP, const int indexP, cIptvProtocolIf* protocolP)
{ {
debug("cIptvStreamer::Set(): %s:%d\n", Location, Parameter); debug("cIptvStreamer::Set('%s', %d, %d)\n", locationP, parameterP, indexP);
if (!isempty(Location)) { if (!isempty(locationP)) {
// Update protocol and set location and parameter; Close the existing one if changed // Update protocol and set location and parameter; Close the existing one if changed
if (protocol != Protocol) { if (protocolM != protocolP) {
if (protocol) if (protocolM)
protocol->Close(); protocolM->Close();
protocol = Protocol; protocolM = protocolP;
if (protocol) { if (protocolM) {
protocol->Set(Location, Parameter, Index); protocolM->Set(locationP, parameterP, indexP);
protocol->Open(); protocolM->Open();
} }
} }
else if (protocol) else if (protocolM)
protocol->Set(Location, Parameter, Index); protocolM->Set(locationP, parameterP, indexP);
} }
return true; return true;
} }
@ -108,8 +108,8 @@ bool cIptvStreamer::Set(const char* Location, const int Parameter, const int Ind
cString cIptvStreamer::GetInformation(void) cString cIptvStreamer::GetInformation(void)
{ {
//debug("cIptvStreamer::GetInformation()"); //debug("cIptvStreamer::GetInformation()");
cString info; cString s;
if (protocol) if (protocolM)
info = protocol->GetInformation(); s = protocolM->GetInformation();
return info; return s;
} }

14
streamer.h
View File

@ -18,19 +18,19 @@
class cIptvStreamer : public cThread, public cIptvStreamerStatistics { class cIptvStreamer : public cThread, public cIptvStreamerStatistics {
private: private:
cRingBufferLinear* ringBuffer; cRingBufferLinear* ringBufferM;
cCondWait sleep; cCondWait sleepM;
unsigned char* packetBuffer; unsigned char* packetBufferM;
unsigned int packetBufferLen; unsigned int packetBufferLenM;
cIptvProtocolIf* protocol; cIptvProtocolIf* protocolM;
protected: protected:
virtual void Action(void); virtual void Action(void);
public: public:
cIptvStreamer(cRingBufferLinear* RingBuffer, unsigned int PacketLen); cIptvStreamer(cRingBufferLinear* ringBufferP, unsigned int packetLenP);
virtual ~cIptvStreamer(); virtual ~cIptvStreamer();
bool Set(const char* Location, const int Parameter, const int Index, cIptvProtocolIf* Protocol); bool Set(const char* locationP, const int parameterP, const int indexP, cIptvProtocolIf* protocolP);
bool Open(void); bool Open(void);
bool Close(void); bool Close(void);
cString GetInformation(void); cString GetInformation(void);