summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--libtmdb/tmdb-proxy.h5
-rw-r--r--p2pvr/carddaemon/carddaemon.cpp8
-rw-r--r--p2pvr/daemon/daemon.cpp18
-rw-r--r--p2pvr/daemon/globalDevices.cpp26
-rw-r--r--p2pvr/daemon/globalDevices.h14
-rw-r--r--p2pvr/daemon/icetraySupport.cpp10
-rw-r--r--p2pvr/daemon/icetraySupport.h14
-rw-r--r--p2pvr/daemon/maintenance.cpp18
-rw-r--r--p2pvr/daemon/maintenance.h6
-rw-r--r--p2pvr/daemon/maintenance/events.cpp24
-rw-r--r--p2pvr/daemon/maintenance/network.cpp31
-rw-r--r--p2pvr/daemon/maintenance/services.cpp14
-rw-r--r--p2pvr/daemon/muxedFileSink.cpp2
-rw-r--r--p2pvr/daemon/muxedFileSink.h2
-rw-r--r--p2pvr/daemon/recorder.cpp40
-rw-r--r--p2pvr/daemon/recorder.h18
-rw-r--r--p2pvr/daemon/recordings.cpp18
-rw-r--r--p2pvr/daemon/recordings.h10
-rw-r--r--p2pvr/daemon/schedulers/bitDumbScheduler.cpp2
-rw-r--r--p2pvr/daemon/schedules.cpp30
-rw-r--r--p2pvr/daemon/schedules.h16
-rw-r--r--p2pvr/daemon/si.cpp103
-rw-r--r--p2pvr/daemon/si.h22
-rw-r--r--p2pvr/daemon/storage.cpp32
-rw-r--r--p2pvr/daemon/storage.h12
-rw-r--r--p2pvr/daemon/unittests/mockDefs.cpp20
-rw-r--r--p2pvr/daemon/unittests/mockDefs.h20
-rw-r--r--p2pvr/daemon/unittests/mockDevices.cpp18
-rw-r--r--p2pvr/daemon/unittests/mockDevices.h14
-rw-r--r--p2pvr/daemon/unittests/mockRecorder.cpp5
-rw-r--r--p2pvr/daemon/unittests/mockRecorder.h6
-rw-r--r--p2pvr/daemon/unittests/mockScheduler.cpp4
-rw-r--r--p2pvr/daemon/unittests/mockScheduler.h16
-rw-r--r--p2pvr/daemon/unittests/testErrorHandling.cpp36
-rw-r--r--p2pvr/daemon/unittests/testMaint.cpp7
-rw-r--r--p2pvr/daemon/unittests/testRecording.cpp13
-rw-r--r--p2pvr/daemon/unittests/testRecordings.cpp3
-rw-r--r--p2pvr/daemon/unittests/testSched.cpp7
-rw-r--r--p2pvr/daemon/unittests/testSi.cpp3
-rw-r--r--p2pvr/daemon/unittests/testStorage.cpp7
-rw-r--r--p2pvr/devices/frontend.cpp6
-rw-r--r--p2pvr/devices/frontend.h4
-rw-r--r--p2pvr/devices/frontends/ofdm.cpp14
-rw-r--r--p2pvr/devices/localDevices.cpp60
-rw-r--r--p2pvr/devices/localDevices.h22
-rw-r--r--p2pvr/devices/mockTuner.cpp4
-rw-r--r--p2pvr/devices/mockTuner.h28
-rw-r--r--p2pvr/devices/tuner.cpp56
-rw-r--r--p2pvr/devices/tuner.h40
-rw-r--r--p2pvr/devices/tunerSendSi.cpp18
-rw-r--r--p2pvr/devices/tunerSendSi.h4
-rw-r--r--p2pvr/devices/tunerSendTs.cpp11
-rw-r--r--p2pvr/devices/tunerSendTs.h4
-rw-r--r--p2pvr/dvb/bindDataHandler.cpp6
-rw-r--r--p2pvr/dvb/bindDataHandler.h10
-rw-r--r--p2pvr/dvb/bindSiParserHandler.h4
-rw-r--r--p2pvr/dvb/siParsers/event.cpp18
-rw-r--r--p2pvr/dvb/siParsers/event.h22
-rw-r--r--p2pvr/dvb/siParsers/network.cpp47
-rw-r--r--p2pvr/dvb/siParsers/network.h18
-rw-r--r--p2pvr/dvb/siParsers/programAssociation.cpp5
-rw-r--r--p2pvr/dvb/siParsers/programAssociation.h4
-rw-r--r--p2pvr/dvb/siParsers/programMap.cpp9
-rw-r--r--p2pvr/dvb/siParsers/programMap.h10
-rw-r--r--p2pvr/dvb/siParsers/service.cpp12
-rw-r--r--p2pvr/dvb/siParsers/service.h12
-rw-r--r--p2pvr/dvb/siParsers/table.cpp4
-rw-r--r--p2pvr/dvb/siParsers/table.h4
-rw-r--r--p2pvr/dvb/unittests/createBroadcast.cpp42
-rw-r--r--p2pvr/dvb/unittests/createSamples.cpp45
-rw-r--r--p2pvr/lib/bindTimerTask.cpp2
-rw-r--r--p2pvr/lib/bindTimerTask.h2
-rw-r--r--p2pvr/lib/fileHandle.cpp2
-rw-r--r--p2pvr/lib/fileHandle.h2
-rw-r--r--p2pvr/lib/fileSink.cpp4
-rw-r--r--p2pvr/lib/fileSink.h6
-rw-r--r--p2pvr/lib/muxer.cpp12
-rw-r--r--p2pvr/lib/muxer.h10
-rw-r--r--p2pvr/lib/serviceStreamer.cpp4
-rw-r--r--p2pvr/lib/serviceStreamer.h6
-rw-r--r--p2pvr/lib/serviceStreamerCore.cpp18
-rw-r--r--p2pvr/lib/serviceStreamerCore.h26
-rw-r--r--p2pvr/lib/temporaryIceAdapterObject.h2
83 files changed, 792 insertions, 521 deletions
diff --git a/libtmdb/tmdb-proxy.h b/libtmdb/tmdb-proxy.h
index c5490a3..472e522 100644
--- a/libtmdb/tmdb-proxy.h
+++ b/libtmdb/tmdb-proxy.h
@@ -1,9 +1,9 @@
#include <tmdb-api.h>
#include "httpClient.h"
+#include <visibility.h>
-#pragma GCC visibility push(default)
namespace TMDb {
- class Proxy : public API, private HttpClient {
+ class DLL_PUBLIC Proxy : public API, private HttpClient {
public:
Proxy(const std::string & baseUrl, const std::string & apikey);
@@ -15,5 +15,4 @@ namespace TMDb {
TvSeriesPtr GetTvSeries(Ice::Int, const Ice::Current&) override;
};
};
-#pragma GCC visibility pop
diff --git a/p2pvr/carddaemon/carddaemon.cpp b/p2pvr/carddaemon/carddaemon.cpp
index d48bb0c..f7889e8 100644
--- a/p2pvr/carddaemon/carddaemon.cpp
+++ b/p2pvr/carddaemon/carddaemon.cpp
@@ -4,14 +4,16 @@
#include <Ice/Communicator.h>
#include <IceUtil/Timer.h>
-class P2PvrCardDaemon : public IceTray::Service {
+namespace P2PVR {
+class CardDaemon : public IceTray::Service {
public:
void addObjects(const std::string &, const Ice::CommunicatorPtr & ic, const Ice::StringSeq &, const Ice::ObjectAdapterPtr & adapter) override
{
IceUtil::TimerPtr timer = new IceUtil::Timer();
- adapter->add(new LocalDevices(adapter, timer), ic->stringToIdentity("Devices"));
+ adapter->add(new LocalDevicesI(adapter, timer), ic->stringToIdentity("Devices"));
}
};
-FACTORY(P2PvrCardDaemon, IceTray::ServiceFactory);
+FACTORY(CardDaemon, IceTray::ServiceFactory);
+}
diff --git a/p2pvr/daemon/daemon.cpp b/p2pvr/daemon/daemon.cpp
index 6a62457..109086a 100644
--- a/p2pvr/daemon/daemon.cpp
+++ b/p2pvr/daemon/daemon.cpp
@@ -10,6 +10,7 @@
#include <tmdb-proxy.h>
#include <icetrayService.h>
+namespace P2PVR {
// These configure external components and so they live here
class P2PVRTMDb : public IceTray::Options {
public:
@@ -36,14 +37,14 @@ class P2PvrDaemon : public IceTray::Service {
IceUtil::TimerPtr timer = new IceUtil::Timer();
auto db = getConnectionPool(ic, "postgresql", "postgres");
- auto localDevices = add<P2PVR::LocalDevices>(ic, adapter, new LocalDevices(adapter, timer), "Devices");
- auto globalDevices = add<P2PVR::Devices>(ic, adapter, new GlobalDevices(), "GlobalDevices");
- auto maintenance = add<P2PVR::Maintenance>(ic, adapter, new Maintenance(db, adapter, timer), "Maintenance");
- auto si = add<P2PVR::SI>(ic, adapter, new SI(db), "SI");
- auto schedules = add<P2PVR::Schedules>(ic, adapter, new Schedules(db), "Schedules");
- auto storage = add<P2PVR::Storage>(ic, adapter, new Storage(), "Storage");
- auto recorder = add<P2PVR::Recorder>(ic, adapter, new Recorder(adapter, timer), "Recorder");
- auto recordings = add<P2PVR::Recordings>(ic, adapter, new Recordings(db), "Recordings");
+ auto localDevices = add<LocalDevices>(ic, adapter, new LocalDevicesI(adapter, timer), "Devices");
+ auto globalDevices = add<Devices>(ic, adapter, new GlobalDevices(), "GlobalDevices");
+ auto maintenance = add<Maintenance>(ic, adapter, new MaintenanceI(db, adapter, timer), "Maintenance");
+ auto si = add<SI>(ic, adapter, new SII(db), "SI");
+ auto schedules = add<Schedules>(ic, adapter, new SchedulesI(db), "Schedules");
+ auto storage = add<Storage>(ic, adapter, new StorageI(), "Storage");
+ auto recorder = add<Recorder>(ic, adapter, new RecorderI(adapter, timer), "Recorder");
+ auto recordings = add<Recordings>(ic, adapter, new RecordingsI(db), "Recordings");
auto tmdb = add<TMDb::Proxy>(ic, adapter, new TMDb::Proxy(tmdbOpts->baseUrl, tmdbOpts->apikey), "TMDb");
}
@@ -55,4 +56,5 @@ class P2PvrDaemon : public IceTray::Service {
};
FACTORY(P2PvrDaemon, IceTray::ServiceFactory);
+}
diff --git a/p2pvr/daemon/globalDevices.cpp b/p2pvr/daemon/globalDevices.cpp
index 4557fc6..0705415 100644
--- a/p2pvr/daemon/globalDevices.cpp
+++ b/p2pvr/daemon/globalDevices.cpp
@@ -3,6 +3,7 @@
namespace po = boost::program_options;
+namespace P2PVR {
GlobalDevices::Options::Options() :
IceTray::Options("P2PVR Devices")
{
@@ -13,57 +14,57 @@ ICETRAY_OPTIONS(GlobalDevices::Options,
"ICE address of remote device pools (<object>:<endpoint>)")
)
-P2PVR::TunerPrx
+TunerPrx
GlobalDevices::GetTunerSpecific(const DVBSI::DeliveryPtr & delivery, const Ice::Current & ice)
{
auto ic = ice.adapter->getCommunicator();
for (const auto & pool : options->Devices) {
try {
- auto poolprx = P2PVR::DevicesPrx::checkedCast(ic->stringToProxy(pool));
+ auto poolprx = DevicesPrx::checkedCast(ic->stringToProxy(pool));
return poolprx->GetTunerSpecific(delivery);
}
catch (...) {
}
}
- throw P2PVR::NoSuitableDeviceAvailable();
+ throw NoSuitableDeviceAvailable();
}
-P2PVR::TunerPrx
+TunerPrx
GlobalDevices::GetTunerAny(const DVBSI::DeliveryPtr & delivery, const Ice::Current & ice)
{
auto ic = ice.adapter->getCommunicator();
for (const auto & pool : options->Devices) {
try {
- auto poolprx = P2PVR::DevicesPrx::checkedCast(ic->stringToProxy(pool));
+ auto poolprx = DevicesPrx::checkedCast(ic->stringToProxy(pool));
return poolprx->GetTunerAny(delivery);
}
catch (...) {
}
}
- throw P2PVR::NoSuitableDeviceAvailable();
+ throw NoSuitableDeviceAvailable();
}
-P2PVR::PrivateTunerPrx
+PrivateTunerPrx
GlobalDevices::GetPrivateTuner(short type, const Ice::Current & ice)
{
auto ic = ice.adapter->getCommunicator();
for (const auto & pool : options->Devices) {
try {
- auto poolprx = P2PVR::DevicesPrx::checkedCast(ic->stringToProxy(pool));
+ auto poolprx = DevicesPrx::checkedCast(ic->stringToProxy(pool));
return poolprx->GetPrivateTuner(type);
}
catch (...) {
}
}
- throw P2PVR::NoSuitableDeviceAvailable();
+ throw NoSuitableDeviceAvailable();
}
void
-GlobalDevices::ReleaseTuner(const P2PVR::TunerPrx & tuner, const Ice::Current & ice)
+GlobalDevices::ReleaseTuner(const TunerPrx & tuner, const Ice::Current & ice)
{
auto ic = ice.adapter->getCommunicator();
for (const auto & pool : options->Devices) {
- auto poolprx = P2PVR::DevicesPrx::checkedCast(ic->stringToProxy(pool));
+ auto poolprx = DevicesPrx::checkedCast(ic->stringToProxy(pool));
poolprx->ReleaseTuner(tuner);
}
}
@@ -75,7 +76,7 @@ GlobalDevices::TunerCount(const Ice::Current & ice)
auto ic = ice.adapter->getCommunicator();
for (const auto & pool : options->Devices) {
try {
- auto poolprx = P2PVR::DevicesPrx::checkedCast(ic->stringToProxy(pool));
+ auto poolprx = DevicesPrx::checkedCast(ic->stringToProxy(pool));
total += poolprx->TunerCount();
}
catch (...) {
@@ -84,4 +85,5 @@ GlobalDevices::TunerCount(const Ice::Current & ice)
}
return total;
}
+}
diff --git a/p2pvr/daemon/globalDevices.h b/p2pvr/daemon/globalDevices.h
index cffb491..c5097b3 100644
--- a/p2pvr/daemon/globalDevices.h
+++ b/p2pvr/daemon/globalDevices.h
@@ -1,14 +1,15 @@
#ifndef GLOBALDEVICES_H
#define GLOBALDEVICES_H
-// Global devices implements a device collection (P2PVR::Devices) for any devices known
+// Global devices implements a device collection (Devices) for any devices known
// throughout the system through other Devices interfaces
#include <dvb.h>
#include <options.h>
#include <visibility.h>
-class DLL_PUBLIC GlobalDevices : public P2PVR::Devices {
+namespace P2PVR {
+class DLL_PUBLIC GlobalDevices : public Devices {
public:
class Options : public IceTray::Options {
public:
@@ -19,15 +20,16 @@ class DLL_PUBLIC GlobalDevices : public P2PVR::Devices {
std::vector<std::string> Devices;
};
- P2PVR::TunerPrx GetTunerSpecific(const DVBSI::DeliveryPtr &, const Ice::Current &);
- P2PVR::TunerPrx GetTunerAny(const DVBSI::DeliveryPtr &, const Ice::Current &);
- P2PVR::PrivateTunerPrx GetPrivateTuner(short type, const Ice::Current &);
- void ReleaseTuner(const P2PVR::TunerPrx &, const Ice::Current &);
+ TunerPrx GetTunerSpecific(const DVBSI::DeliveryPtr &, const Ice::Current &);
+ TunerPrx GetTunerAny(const DVBSI::DeliveryPtr &, const Ice::Current &);
+ PrivateTunerPrx GetPrivateTuner(short type, const Ice::Current &);
+ void ReleaseTuner(const TunerPrx &, const Ice::Current &);
int TunerCount(const Ice::Current &);
private:
IceTray::OptionsResolver<Options> options;
};
+}
#endif
diff --git a/p2pvr/daemon/icetraySupport.cpp b/p2pvr/daemon/icetraySupport.cpp
new file mode 100644
index 0000000..8f81ec4
--- /dev/null
+++ b/p2pvr/daemon/icetraySupport.cpp
@@ -0,0 +1,10 @@
+#include "icetraySupport.h"
+#include "commonHelpers.h"
+
+template<>
+void
+IceTray::AbstractDatabaseClient::bind1<Common::DateTime>(int x, DB::Command * cmd, const Common::DateTime & dt)
+{
+ cmd->bindParamT(x, *dt);
+}
+
diff --git a/p2pvr/daemon/icetraySupport.h b/p2pvr/daemon/icetraySupport.h
new file mode 100644
index 0000000..4174665
--- /dev/null
+++ b/p2pvr/daemon/icetraySupport.h
@@ -0,0 +1,14 @@
+#ifndef P2PVR_ICETRAY_SUPPORT_H
+#define P2PVR_ICETRAY_SUPPORT_H
+
+#include <abstractDatabaseClient.h>
+#include <common.h>
+
+namespace IceTray {
+ template<>
+ void
+ AbstractDatabaseClient::bind1<Common::DateTime>(int x, DB::Command * cmd, const Common::DateTime &);
+}
+
+#endif
+
diff --git a/p2pvr/daemon/maintenance.cpp b/p2pvr/daemon/maintenance.cpp
index 23eef15..6abad00 100644
--- a/p2pvr/daemon/maintenance.cpp
+++ b/p2pvr/daemon/maintenance.cpp
@@ -9,8 +9,9 @@
namespace po = boost::program_options;
-Maintenance::Options::Options() : IceTray::Options("P2PVR Maintenance options") { }
-ICETRAY_OPTIONS(Maintenance::Options,
+namespace P2PVR {
+MaintenanceI::Options::Options() : IceTray::Options("P2PVR Maintenance options") { }
+ICETRAY_OPTIONS(MaintenanceI::Options,
("p2pvr.maintenance.periodUpdateNetwork", po::value(&periodUpdateNetwork)->default_value(86400 * 7),
"Period between automated updates of DVB network (1 week)")
("p2pvr.maintenance.periodUpdateServices", po::value(&periodUpdateServices)->default_value(86400 * 7),
@@ -21,13 +22,13 @@ ICETRAY_OPTIONS(Maintenance::Options,
"Perform the maintenance circle on start-up (false)")
);
-IceTray::Logging::LoggerPtr Maintenance::logger(LOGMANAGER()->getLogger<Maintenance>());
+IceTray::Logging::LoggerPtr MaintenanceI::logger(LOGMANAGER()->getLogger<MaintenanceI>());
-Maintenance::Maintenance(IceTray::DatabasePoolPtr db, Ice::ObjectAdapterPtr a, IceUtil::TimerPtr t) :
+MaintenanceI::MaintenanceI(IceTray::DatabasePoolPtr db, Ice::ObjectAdapterPtr a, IceUtil::TimerPtr t) :
IceTray::AbstractDatabaseClient(db),
adapter(a),
timer(t),
- clientCheck(new BindTimerTask(boost::bind(&Maintenance::ScheduledUpdate, this))),
+ clientCheck(new BindTimerTask(boost::bind(&MaintenanceI::ScheduledUpdate, this))),
lastUpdateNetwork(0),
lastUpdateServices(0),
lastUpdateEvents(0),
@@ -42,7 +43,7 @@ Maintenance::Maintenance(IceTray::DatabasePoolPtr db, Ice::ObjectAdapterPtr a, I
}
void
-Maintenance::UpdateAll(const Ice::Current & ice)
+MaintenanceI::UpdateAll(const Ice::Current & ice)
{
UpdateAll(FE_OFDM, ice);
UpdateAll(FE_QPSK, ice);
@@ -51,7 +52,7 @@ Maintenance::UpdateAll(const Ice::Current & ice)
}
void
-Maintenance::UpdateAll(short type, const Ice::Current & ice)
+MaintenanceI::UpdateAll(short type, const Ice::Current & ice)
{
UpdateNetwork(type, ice);
UpdateServices(ice);
@@ -59,7 +60,7 @@ Maintenance::UpdateAll(short type, const Ice::Current & ice)
}
void
-Maintenance::ScheduledUpdate()
+MaintenanceI::ScheduledUpdate()
{
logger->messagebf(LOG::DEBUG, "%s: triggered", __PRETTY_FUNCTION__);
if (!updateRunning) {
@@ -97,4 +98,5 @@ Maintenance::ScheduledUpdate()
update.detach();
}
}
+}
diff --git a/p2pvr/daemon/maintenance.h b/p2pvr/daemon/maintenance.h
index c941d06..5299139 100644
--- a/p2pvr/daemon/maintenance.h
+++ b/p2pvr/daemon/maintenance.h
@@ -8,7 +8,8 @@
#include <logger.h>
#include <visibility.h>
-class DLL_PUBLIC Maintenance : public P2PVR::Maintenance, public IceTray::AbstractDatabaseClient {
+namespace P2PVR {
+class DLL_PUBLIC MaintenanceI : public Maintenance, public IceTray::AbstractDatabaseClient {
public:
class Options : public IceTray::Options {
public:
@@ -20,7 +21,7 @@ class DLL_PUBLIC Maintenance : public P2PVR::Maintenance, public IceTray::Abstra
bool scanOnStart;
};
- Maintenance(IceTray::DatabasePoolPtr db, Ice::ObjectAdapterPtr, IceUtil::TimerPtr);
+ MaintenanceI(IceTray::DatabasePoolPtr db, Ice::ObjectAdapterPtr, IceUtil::TimerPtr);
void UpdateAll(const Ice::Current &);
void UpdateAll(short type, const Ice::Current &);
@@ -43,6 +44,7 @@ class DLL_PUBLIC Maintenance : public P2PVR::Maintenance, public IceTray::Abstra
IceTray::OptionsResolver<Options> options;
static IceTray::Logging::LoggerPtr logger;
};
+}
#endif
diff --git a/p2pvr/daemon/maintenance/events.cpp b/p2pvr/daemon/maintenance/events.cpp
index 0f4cf4e..8a642f9 100644
--- a/p2pvr/daemon/maintenance/events.cpp
+++ b/p2pvr/daemon/maintenance/events.cpp
@@ -9,9 +9,10 @@
#include <slicer/modelPartsTypes.impl.h>
#include "sql/maintenance/pruneEvents.sql.h"
-class SiEventsStream : public Slicer::Stream<DVBSI::EventPtr> {
+namespace P2PVR {
+class SiEventsStream : public Slicer::Stream<::DVBSI::EventPtr> {
private:
- class SiEventsHandler : public SiEpgParser {
+ class SiEventsHandler : public DVBSI::SiEpgParser {
public:
SiEventsHandler(const Consumer & c, IceTray::Logging::LoggerPtr l) :
consumer(c),
@@ -19,7 +20,7 @@ class SiEventsStream : public Slicer::Stream<DVBSI::EventPtr> {
{
}
- bool HandleTable(DVBSI::EventPtr e) override
+ bool HandleTable(::DVBSI::EventPtr e) override
{
logger->messagebf(LOG::DEBUG, "Service Id: %d Program Id: %d Title: %s Time: %s - %s",
e->ServiceId, e->EventId, e->Title, e->StartTime, e->StopTime);
@@ -42,8 +43,8 @@ class SiEventsStream : public Slicer::Stream<DVBSI::EventPtr> {
void Produce(const Consumer & ch) override
{
auto ic = ice.adapter->getCommunicator();
- auto devs = P2PVR::DevicesPrx::checkedCast(ice.adapter->createProxy(ic->stringToIdentity("GlobalDevices")));
- auto si = P2PVR::SIPrx::checkedCast(ice.adapter->createProxy(ic->stringToIdentity("SI")));
+ auto devs = DevicesPrx::checkedCast(ice.adapter->createProxy(ic->stringToIdentity("GlobalDevices")));
+ auto si = SIPrx::checkedCast(ice.adapter->createProxy(ic->stringToIdentity("SI")));
if (!devs || !si) {
throw std::runtime_error("bad proxy(s)");
}
@@ -55,7 +56,7 @@ class SiEventsStream : public Slicer::Stream<DVBSI::EventPtr> {
logger->messagebf(LOG::DEBUG, "%s: Getting a tuner", __PRETTY_FUNCTION__);
auto tuner = devs->GetTunerAny(delivery);
logger->messagebf(LOG::DEBUG, "%s: Fetching events", __PRETTY_FUNCTION__);
- TemporaryIceAdapterObject<P2PVR::RawDataClient> parser(ice.adapter, new SiEventsHandler(ch, logger));
+ TemporaryIceAdapterObject<RawDataClient> parser(ice.adapter, new SiEventsHandler(ch, logger));
tuner->SendEventInformation(parser);
devs->ReleaseTuner(tuner);
@@ -66,10 +67,8 @@ class SiEventsStream : public Slicer::Stream<DVBSI::EventPtr> {
const IceTray::Logging::LoggerPtr logger;
};
-MODELPARTFORSTREAM(SiEventsStream);
-
void
-Maintenance::UpdateEvents(const Ice::Current & ice)
+MaintenanceI::UpdateEvents(const Ice::Current & ice)
{
auto dbc = db->get();
auto ic = ice.adapter->getCommunicator();
@@ -84,10 +83,13 @@ Maintenance::UpdateEvents(const Ice::Current & ice)
Slicer::SerializeAny<Slicer::SqlTablePatchSerializer>(stream, dbc.get(), tp);
- P2PVR::sql::maintenance::pruneEvents.modify(dbc.get())->execute();
+ sql::maintenance::pruneEvents.modify(dbc.get())->execute();
logger->messagebf(LOG::INFO, "%s: Updated events", __PRETTY_FUNCTION__);
- auto sch = P2PVR::SchedulesPrx::checkedCast(ice.adapter->createProxy(ic->stringToIdentity("Schedules")));
+ auto sch = SchedulesPrx::checkedCast(ice.adapter->createProxy(ic->stringToIdentity("Schedules")));
sch->DoReschedule();
}
+}
+
+MODELPARTFORSTREAM(P2PVR::SiEventsStream);
diff --git a/p2pvr/daemon/maintenance/network.cpp b/p2pvr/daemon/maintenance/network.cpp
index 4b03f6d..56f3754 100644
--- a/p2pvr/daemon/maintenance/network.cpp
+++ b/p2pvr/daemon/maintenance/network.cpp
@@ -6,7 +6,8 @@
#include <db/sqlInsertSerializer.h>
#include <db/sqlTablePatchSerializer.h>
-class SiNetworkInformationMerger : public SiNetworkInformationParser {
+namespace P2PVR {
+class SiNetworkInformationMerger : public DVBSI::SiNetworkInformationParser {
public:
SiNetworkInformationMerger(DB::Connection * d, IceTray::Logging::LoggerPtr l) :
dbc(d),
@@ -14,7 +15,7 @@ class SiNetworkInformationMerger : public SiNetworkInformationParser {
{
}
- bool HandleTable(DVBSI::NetworkPtr n)
+ bool HandleTable(::DVBSI::NetworkPtr n)
{
logger->messagebf(LOG::DEBUG, "Network Id: %d Name: %s", n->NetworkId, *n->Name);
for (const auto & ts : n->TransportStreams) {
@@ -35,11 +36,11 @@ class SiNetworkInformationMerger : public SiNetworkInformationParser {
mergeTransportStreams.dest = "transportstreams";
Slicer::SerializeAny<Slicer::SqlTablePatchSerializer>(n->TransportStreams, dbc, mergeTransportStreams);
- mergeDelivery<DVBSI::TerrestrialDeliveryPtr, &DVBSI::NetworkTransportStream::Terrestrial>("delivery_dvbt", n);
- mergeDelivery<DVBSI::SatelliteDeliveryPtr, &DVBSI::NetworkTransportStream::Satellite>("delivery_dvbs", n);
- mergeDelivery<DVBSI::CableDeliveryPtr, &DVBSI::NetworkTransportStream::Cable>("delivery_dvbc", n);
+ mergeDelivery<::DVBSI::TerrestrialDeliveryPtr, &::DVBSI::NetworkTransportStream::Terrestrial>("delivery_dvbt", n);
+ mergeDelivery<::DVBSI::SatelliteDeliveryPtr, &::DVBSI::NetworkTransportStream::Satellite>("delivery_dvbs", n);
+ mergeDelivery<::DVBSI::CableDeliveryPtr, &::DVBSI::NetworkTransportStream::Cable>("delivery_dvbc", n);
- DVBSI::NetworkServiceList services;
+ ::DVBSI::NetworkServiceList services;
for (const auto & ts : n->TransportStreams) {
for (const auto & s : ts->Services) {
services.push_back(s);
@@ -52,8 +53,9 @@ class SiNetworkInformationMerger : public SiNetworkInformationParser {
return false;
}
private:
- template <class Delivery, Delivery DVBSI::NetworkTransportStream::*member>
- void mergeDelivery(const std::string & table, DVBSI::NetworkPtr n)
+ typedef ::DVBSI::NetworkTransportStream NTS;
+ template <class Delivery, Delivery NTS::*member>
+ void mergeDelivery(const std::string & table, ::DVBSI::NetworkPtr n)
{
DB::TablePatch tp;
tp.dest = table;
@@ -70,14 +72,14 @@ class SiNetworkInformationMerger : public SiNetworkInformationParser {
};
void
-Maintenance::UpdateNetwork(short type, const Ice::Current & ice)
+MaintenanceI::UpdateNetwork(short type, const Ice::Current & ice)
{
auto dbc = db->get();
auto ic = ice.adapter->getCommunicator();
- auto devs = P2PVR::DevicesPrx::checkedCast(ice.adapter->createProxy(ic->stringToIdentity("GlobalDevices")));
- auto si = P2PVR::SIPrx::checkedCast(ice.adapter->createProxy(ic->stringToIdentity("SI")));
+ auto devs = DevicesPrx::checkedCast(ice.adapter->createProxy(ic->stringToIdentity("GlobalDevices")));
+ auto si = SIPrx::checkedCast(ice.adapter->createProxy(ic->stringToIdentity("SI")));
auto siparser = new SiNetworkInformationMerger(dbc.get(), logger);
- TemporaryIceAdapterObject<P2PVR::RawDataClient> parser(ice.adapter, siparser);
+ TemporaryIceAdapterObject<RawDataClient> parser(ice.adapter, siparser);
if (!devs) {
throw std::runtime_error("bad proxy(s)");
@@ -87,14 +89,14 @@ Maintenance::UpdateNetwork(short type, const Ice::Current & ice)
auto transport = si->GetDeliveryForSi();
if (transport) {
- P2PVR::TunerPrx tuner;
+ TunerPrx tuner;
try {
tuner = devs->GetTunerAny(transport);
tuner->SendNetworkInformation(parser);
devs->ReleaseTuner(tuner);
return;
}
- catch (const P2PVR::NoSuitableDeviceAvailable &) {
+ catch (const NoSuitableDeviceAvailable &) {
logger->messagebf(LOG::WARNING, "%s: Failed to get a suitable tuner", __PRETTY_FUNCTION__);
throw;
}
@@ -114,4 +116,5 @@ Maintenance::UpdateNetwork(short type, const Ice::Current & ice)
tuner->ScanAndSendNetworkInformation(parser);
devs->ReleaseTuner(tuner);
}
+}
diff --git a/p2pvr/daemon/maintenance/services.cpp b/p2pvr/daemon/maintenance/services.cpp
index 315ca0e..e04c200 100644
--- a/p2pvr/daemon/maintenance/services.cpp
+++ b/p2pvr/daemon/maintenance/services.cpp
@@ -7,7 +7,8 @@
#include <db/sqlTablePatchSerializer.h>
#include <tablepatch.h>
-class SiServicesMerger : public SiServicesParser {
+namespace P2PVR {
+class SiServicesMerger : public DVBSI::SiServicesParser {
public:
SiServicesMerger(IceTray::Logging::LoggerPtr l, DB::Connection * d) :
logger(l),
@@ -15,7 +16,7 @@ class SiServicesMerger : public SiServicesParser {
{
}
- bool HandleTable(DVBSI::TransportStreamPtr ts)
+ bool HandleTable(::DVBSI::TransportStreamPtr ts)
{
logger->messagebf(LOG::DEBUG, "Transport Stream Id: %d Original Network Id: %s", ts->TransportStreamId, ts->OriginalNetworkId);
for (const auto & s : ts->Services) {
@@ -39,11 +40,11 @@ class SiServicesMerger : public SiServicesParser {
};
void
-Maintenance::UpdateServices(const Ice::Current & ice)
+MaintenanceI::UpdateServices(const Ice::Current & ice)
{
auto ic = ice.adapter->getCommunicator();
- auto devs = P2PVR::DevicesPrx::checkedCast(ice.adapter->createProxy(ic->stringToIdentity("GlobalDevices")));
- auto si = P2PVR::SIPrx::checkedCast(ice.adapter->createProxy(ic->stringToIdentity("SI")));
+ auto devs = DevicesPrx::checkedCast(ice.adapter->createProxy(ic->stringToIdentity("GlobalDevices")));
+ auto si = SIPrx::checkedCast(ice.adapter->createProxy(ic->stringToIdentity("SI")));
if (!devs || !si) {
throw std::runtime_error("bad proxy(s)");
@@ -51,7 +52,7 @@ Maintenance::UpdateServices(const Ice::Current & ice)
auto dbc = db->get();
auto siparser = new SiServicesMerger(logger, dbc.get());
- TemporaryIceAdapterObject<P2PVR::RawDataClient> parser(ice.adapter, siparser);
+ TemporaryIceAdapterObject<RawDataClient> parser(ice.adapter, siparser);
auto delivery = si->GetDeliveryForSi();
if (!delivery) {
@@ -66,4 +67,5 @@ Maintenance::UpdateServices(const Ice::Current & ice)
logger->messagebf(LOG::INFO, "%s: Updated service list", __PRETTY_FUNCTION__);
devs->ReleaseTuner(tuner);
}
+}
diff --git a/p2pvr/daemon/muxedFileSink.cpp b/p2pvr/daemon/muxedFileSink.cpp
index ff6ec35..ff431bc 100644
--- a/p2pvr/daemon/muxedFileSink.cpp
+++ b/p2pvr/daemon/muxedFileSink.cpp
@@ -6,6 +6,7 @@
#include <boost/algorithm/string/split.hpp>
#include <boost/algorithm/string/classification.hpp>
+namespace P2PVR {
class MuxerFailure : public P2PVR::DataHandlingException { };
MuxedFileSink::MuxedFileSink(const boost::filesystem::path & t, const std::string & cmd) :
@@ -123,4 +124,5 @@ MuxedFileSink::ReadMuxer(int waitTime) const
}
}
}
+}
diff --git a/p2pvr/daemon/muxedFileSink.h b/p2pvr/daemon/muxedFileSink.h
index d252372..d91e106 100644
--- a/p2pvr/daemon/muxedFileSink.h
+++ b/p2pvr/daemon/muxedFileSink.h
@@ -8,6 +8,7 @@
#include <processPipes.h>
#include <logger.h>
+namespace P2PVR {
class MuxedFileSink : public P2PVR::RawDataClient {
public:
MuxedFileSink(const boost::filesystem::path & target, const std::string & cmd);
@@ -25,6 +26,7 @@ class MuxedFileSink : public P2PVR::RawDataClient {
IceTray::Logging::LoggerPtr logger;
};
+}
#endif
diff --git a/p2pvr/daemon/recorder.cpp b/p2pvr/daemon/recorder.cpp
index 548ad11..28e89ee 100644
--- a/p2pvr/daemon/recorder.cpp
+++ b/p2pvr/daemon/recorder.cpp
@@ -13,21 +13,22 @@
namespace po = boost::program_options;
-Recorder::Options::Options() :
+namespace P2PVR {
+RecorderI::Options::Options() :
IceTray::Options("P2PVR Recorder options")
{
}
-ICETRAY_OPTIONS(Recorder::Options,
+ICETRAY_OPTIONS(RecorderI::Options,
("p2pvr.recorder.extension", po::value(&extension)->default_value("mp4"),
"File extension to save with (default: mp4)")
("p2pvr.recorder.muxercommand", po::value(&muxerCommand)->default_value("/usr/bin/ffmpeg -f mpegts -i - -f dvd -codec copy -"),
"Command to perform TS->PS muxing (default: '/usr/bin/ffmpeg -f mpegts -i - -f dvd -codec copy -')")
);
-IceTray::Logging::LoggerPtr Recorder::logger(LOGMANAGER()->getLogger<Recorder>());
+IceTray::Logging::LoggerPtr RecorderI::logger(LOGMANAGER()->getLogger<RecorderI>());
-Recorder::Recorder(Ice::ObjectAdapterPtr a, IceUtil::TimerPtr t) :
+RecorderI::RecorderI(Ice::ObjectAdapterPtr a, IceUtil::TimerPtr t) :
adapter(a),
timer(t)
{
@@ -36,15 +37,15 @@ Recorder::Recorder(Ice::ObjectAdapterPtr a, IceUtil::TimerPtr t) :
}
void
-Recorder::RefreshSchedules(const Ice::Current &)
+RecorderI::RefreshSchedules(const Ice::Current &)
{
std::lock_guard<std::mutex> g(lock);
for (auto & t : pendingRecordings) {
timer->cancel(t);
}
pendingRecordings.clear();
- auto schedules = P2PVR::SchedulesPrx::checkedCast(adapter->createProxy(adapter->getCommunicator()->stringToIdentity("Schedules")));
- auto si = P2PVR::SIPrx::checkedCast(adapter->createProxy(adapter->getCommunicator()->stringToIdentity("SI")));
+ auto schedules = SchedulesPrx::checkedCast(adapter->createProxy(adapter->getCommunicator()->stringToIdentity("Schedules")));
+ auto si = SIPrx::checkedCast(adapter->createProxy(adapter->getCommunicator()->stringToIdentity("SI")));
for (const auto & s : schedules->GetScheduledToRecord()) {
if (std::find_if(currentRecordings.begin(), currentRecordings.end(), [&s](const CurrentPtr & c) {
return s->ScheduleId == c->schedule->ScheduleId && s->EventUid == c->event->EventUid;
@@ -56,7 +57,7 @@ Recorder::RefreshSchedules(const Ice::Current &)
auto service = si->GetService(event->ServiceId);
auto startIn = std::max<time_t>((*event->StartTime - *schedule->Early - boost::posix_time::second_clock::universal_time()).total_seconds(), 0);
- IceUtil::TimerTaskPtr startTimer = new BindTimerTask(boost::bind(&Recorder::StartRecording, this, schedule, service, event));
+ IceUtil::TimerTaskPtr startTimer = new BindTimerTask(boost::bind(&RecorderI::StartRecording, this, schedule, service, event));
timer->schedule(startTimer, IceUtil::Time::seconds(startIn));
pendingRecordings.push_back(startTimer);
logger->messagebf(LOG::DEBUG, "Recording %s scheduled for %s seconds", event->Title, startIn);
@@ -64,21 +65,21 @@ Recorder::RefreshSchedules(const Ice::Current &)
}
void
-Recorder::StartRecording(P2PVR::SchedulePtr schedule, DVBSI::ServicePtr service, P2PVR::EventPtr event)
+RecorderI::StartRecording(SchedulePtr schedule, ::DVBSI::ServicePtr service, EventPtr event)
{
std::lock_guard<std::mutex> g(lock);
- auto storage = P2PVR::StoragePrx::checkedCast(adapter->createProxy(adapter->getCommunicator()->stringToIdentity("Storage")));
- auto recordings = P2PVR::RecordingsPrx::checkedCast(adapter->createProxy(adapter->getCommunicator()->stringToIdentity("Recordings")));
- auto devices = P2PVR::DevicesPrx::checkedCast(adapter->createProxy(adapter->getCommunicator()->stringToIdentity("GlobalDevices")));
- auto si = P2PVR::SIPrx::checkedCast(adapter->createProxy(adapter->getCommunicator()->stringToIdentity("SI")));
+ auto storage = StoragePrx::checkedCast(adapter->createProxy(adapter->getCommunicator()->stringToIdentity("Storage")));
+ auto recordings = RecordingsPrx::checkedCast(adapter->createProxy(adapter->getCommunicator()->stringToIdentity("Recordings")));
+ auto devices = DevicesPrx::checkedCast(adapter->createProxy(adapter->getCommunicator()->stringToIdentity("GlobalDevices")));
+ auto si = SIPrx::checkedCast(adapter->createProxy(adapter->getCommunicator()->stringToIdentity("SI")));
auto id = boost::lexical_cast<std::string>(boost::uuids::random_generator()());
auto store = storage->OpenForWrite(id);
AdHoc::ScopeExit _store(NULL, NULL, [this,&store,&storage,&id]() { storage->Close(store); storage->Delete(id); });
auto target = store;
- P2PVR::RawDataClientPrx muxer;
+ RawDataClientPrx muxer;
if (!options->muxerCommand.empty()) {
- muxer = P2PVR::RawDataClientPrx::checkedCast(adapter->addWithUUID(new Muxer(store, options->muxerCommand)));
+ muxer = RawDataClientPrx::checkedCast(adapter->addWithUUID(new Muxer(store, options->muxerCommand)));
target = muxer;
}
AdHoc::ScopeExit _muxer(NULL, NULL, [this,&muxer]() { if (muxer) adapter->remove(muxer->ice_getIdentity()); });
@@ -89,18 +90,18 @@ Recorder::StartRecording(P2PVR::SchedulePtr schedule, DVBSI::ServicePtr service,
event->Title, event->StartTime, event->StopTime,
service->Name ? *service->Name : "<no name>", service->ServiceId);
- recordings->NewRecording(new P2PVR::Recording(0, storage->ice_toString(), id, schedule->ScheduleId, event->EventUid));
+ recordings->NewRecording(new Recording(0, storage->ice_toString(), id, schedule->ScheduleId, event->EventUid));
auto newCurrent = CurrentPtr(new Current({muxer, store, ss, schedule, service, event, IceUtil::TimerTaskPtr()}));
currentRecordings.insert(newCurrent);
auto stopIn = (*event->StopTime + *schedule->Late - boost::posix_time::second_clock::universal_time()).total_seconds();
- newCurrent->stopTimer = new BindTimerTask(boost::bind(&Recorder::StopRecording, this, newCurrent));
+ newCurrent->stopTimer = new BindTimerTask(boost::bind(&RecorderI::StopRecording, this, newCurrent));
timer->schedule(newCurrent->stopTimer, IceUtil::Time::seconds(stopIn));
logger->messagebf(LOG::DEBUG, "Recording %s scheduled stop in %s seconds", event->Title, stopIn);
}
void
-Recorder::StopRecording(CurrentPtr c)
+RecorderI::StopRecording(CurrentPtr c)
{
std::lock_guard<std::mutex> g(lock);
logger->messagebf(LOG::DEBUG, "Stopping %s", c->event->Title);
@@ -109,8 +110,9 @@ Recorder::StopRecording(CurrentPtr c)
adapter->remove(c->muxer->ice_getIdentity());
}
currentRecordings.erase(c);
- auto storage = P2PVR::StoragePrx::checkedCast(adapter->createProxy(adapter->getCommunicator()->stringToIdentity("Storage")));
+ auto storage = StoragePrx::checkedCast(adapter->createProxy(adapter->getCommunicator()->stringToIdentity("Storage")));
storage->Close(c->store);
logger->messagebf(LOG::DEBUG, "Stopped %s", c->event->Title);
}
+}
diff --git a/p2pvr/daemon/recorder.h b/p2pvr/daemon/recorder.h
index e6ff42a..6effb07 100644
--- a/p2pvr/daemon/recorder.h
+++ b/p2pvr/daemon/recorder.h
@@ -10,7 +10,8 @@
#include <visibility.h>
#include <logger.h>
-class DLL_PUBLIC Recorder : public P2PVR::Recorder {
+namespace P2PVR {
+class DLL_PUBLIC RecorderI : public Recorder {
public:
class Options : public IceTray::Options {
public:
@@ -26,23 +27,23 @@ class DLL_PUBLIC Recorder : public P2PVR::Recorder {
class Current {
public:
- P2PVR::RawDataClientPrx muxer;
- P2PVR::RawDataClientPrx store;
+ RawDataClientPrx muxer;
+ RawDataClientPrx store;
ServiceStreamerPtr stream;
- P2PVR::SchedulePtr schedule;
- DVBSI::ServicePtr service;
- P2PVR::EventPtr event;
+ SchedulePtr schedule;
+ ::DVBSI::ServicePtr service;
+ EventPtr event;
IceUtil::TimerTaskPtr stopTimer;
};
typedef boost::shared_ptr<Current> CurrentPtr;
typedef std::set<CurrentPtr> Currents;
- Recorder(Ice::ObjectAdapterPtr a, IceUtil::TimerPtr);
+ RecorderI(Ice::ObjectAdapterPtr a, IceUtil::TimerPtr);
void RefreshSchedules(const Ice::Current &);
private:
- DLL_PRIVATE void StartRecording(P2PVR::SchedulePtr schedule, DVBSI::ServicePtr service, P2PVR::EventPtr event);
+ DLL_PRIVATE void StartRecording(SchedulePtr schedule, ::DVBSI::ServicePtr service, EventPtr event);
DLL_PRIVATE void StopRecording(CurrentPtr);
Ice::ObjectAdapterPtr adapter;
@@ -55,6 +56,7 @@ class DLL_PUBLIC Recorder : public P2PVR::Recorder {
IceTray::OptionsResolver<Options> options;
static IceTray::Logging::LoggerPtr logger;
};
+}
#endif
diff --git a/p2pvr/daemon/recordings.cpp b/p2pvr/daemon/recordings.cpp
index 5570d4c..6efa78c 100644
--- a/p2pvr/daemon/recordings.cpp
+++ b/p2pvr/daemon/recordings.cpp
@@ -7,15 +7,16 @@
#include <sql/recordings/deleteById.sql.h>
#include <sql/recordings/getAll.sql.h>
-IceTray::Logging::LoggerPtr Recordings::logger(LOGMANAGER()->getLogger<Recordings>());
+namespace P2PVR {
+IceTray::Logging::LoggerPtr RecordingsI::logger(LOGMANAGER()->getLogger<RecordingsI>());
-Recordings::Recordings(IceTray::DatabasePoolPtr db) :
+RecordingsI::RecordingsI(IceTray::DatabasePoolPtr db) :
IceTray::AbstractDatabaseClient(db)
{
}
Ice::Int
-Recordings::NewRecording(const P2PVR::RecordingPtr & r, const Ice::Current &)
+RecordingsI::NewRecording(const RecordingPtr & r, const Ice::Current &)
{
auto dbc = db->get();
logger->messagebf(LOG::INFO, "%s: Creating new recording %s at %s", __PRETTY_FUNCTION__, r->Guid, r->StorageAddress);
@@ -26,19 +27,20 @@ Recordings::NewRecording(const P2PVR::RecordingPtr & r, const Ice::Current &)
}
void
-Recordings::DeleteRecording(int id, const Ice::Current &)
+RecordingsI::DeleteRecording(int id, const Ice::Current &)
{
auto dbc = db->get();
logger->messagebf(LOG::INFO, "%s: Deleting recording Id: %d", __PRETTY_FUNCTION__, id);
- auto del = P2PVR::sql::recordings::deleteById.modify(dbc.get());
+ auto del = sql::recordings::deleteById.modify(dbc.get());
del->bindParamI(0, id);
del->execute();
}
-P2PVR::RecordingList
-Recordings::GetRecordings(const Ice::Current &)
+RecordingList
+RecordingsI::GetRecordings(const Ice::Current &)
{
logger->message(LOG::DEBUG, __PRETTY_FUNCTION__);
- return fetch<P2PVR::RecordingList>(P2PVR::sql::recordings::getAll);
+ return fetch<RecordingList>(sql::recordings::getAll);
+}
}
diff --git a/p2pvr/daemon/recordings.h b/p2pvr/daemon/recordings.h
index 1182ff6..4c3a54b 100644
--- a/p2pvr/daemon/recordings.h
+++ b/p2pvr/daemon/recordings.h
@@ -7,17 +7,19 @@
#include <logger.h>
#include <abstractDatabaseClient.h>
-class DLL_PUBLIC Recordings : public P2PVR::Recordings, public IceTray::AbstractDatabaseClient {
+namespace P2PVR {
+class DLL_PUBLIC RecordingsI : public Recordings, public IceTray::AbstractDatabaseClient {
public:
- Recordings(IceTray::DatabasePoolPtr db);
+ RecordingsI(IceTray::DatabasePoolPtr db);
- Ice::Int NewRecording(const P2PVR::RecordingPtr & rec, const Ice::Current &);
+ Ice::Int NewRecording(const RecordingPtr & rec, const Ice::Current &);
void DeleteRecording(int recordingId, const Ice::Current &);
- P2PVR::RecordingList GetRecordings(const Ice::Current &);
+ RecordingList GetRecordings(const Ice::Current &);
private:
static IceTray::Logging::LoggerPtr logger;
};
+}
#endif
diff --git a/p2pvr/daemon/schedulers/bitDumbScheduler.cpp b/p2pvr/daemon/schedulers/bitDumbScheduler.cpp
index 10955e5..1c10105 100644
--- a/p2pvr/daemon/schedulers/bitDumbScheduler.cpp
+++ b/p2pvr/daemon/schedulers/bitDumbScheduler.cpp
@@ -1,5 +1,6 @@
#include "../schedules.h"
+namespace P2PVR {
class TheBitDumbScheduler : public EpisodeGroup {
public:
TheBitDumbScheduler(const Episodes & eps) :
@@ -51,4 +52,5 @@ class TheBitDumbScheduler : public EpisodeGroup {
};
NAMEDFACTORY("BitDumb", TheBitDumbScheduler, EpisodeGroupFactory);
+}
diff --git a/p2pvr/daemon/schedules.cpp b/p2pvr/daemon/schedules.cpp
index 389a979..4fd2054 100644
--- a/p2pvr/daemon/schedules.cpp
+++ b/p2pvr/daemon/schedules.cpp
@@ -19,14 +19,15 @@
namespace po = boost::program_options;
-IceTray::Logging::LoggerPtr Schedules::logger(LOGMANAGER()->getLogger<Schedules>());
+namespace P2PVR {
+IceTray::Logging::LoggerPtr SchedulesI::logger(LOGMANAGER()->getLogger<SchedulesI>());
-Schedules::Options::Options() :
+SchedulesI::Options::Options() :
IceTray::Options("P2PVR Scheduler options")
{
}
-ICETRAY_OPTIONS(Schedules::Options,
+ICETRAY_OPTIONS(SchedulesI::Options,
("p2pvr.scheduler.algorithm", po::value(&SchedulerAlgorithm)->default_value("BitDumb"),
"Implementation of episode group scheduler problem solver")
)
@@ -163,13 +164,13 @@ EpisodeGroup::SuggestWithFeedback(const Showings & showings)
}
}
-Schedules::Schedules(IceTray::DatabasePoolPtr db) :
+SchedulesI::SchedulesI(IceTray::DatabasePoolPtr db) :
IceTray::AbstractDatabaseClient(db)
{
}
void
-Schedules::GetEpisodeIntersects(Episodes & all, Episodes & grouped)
+SchedulesI::GetEpisodeIntersects(Episodes & all, Episodes & grouped)
{
for (Episodes::iterator aei = all.begin(); aei != all.end(); aei++) {
const auto & ae = *aei;
@@ -190,14 +191,14 @@ Schedules::GetEpisodeIntersects(Episodes & all, Episodes & grouped)
}
void
-Schedules::DoReschedule(const Ice::Current & ice)
+SchedulesI::DoReschedule(const Ice::Current & ice)
{
auto ic = ice.adapter->getCommunicator();
auto devs = P2PVR::DevicesPrx::checkedCast(ice.adapter->createProxy(ic->stringToIdentity("GlobalDevices")));
unsigned int tunerCount = devs->TunerCount();
// Load list from database
- auto episodes = fetch<P2PVR::ScheduleCandidates>(P2PVR::sql::schedules::getCandidates);
+ auto episodes = fetch<ScheduleCandidates>(P2PVR::sql::schedules::getCandidates);
Episodes scheduleList;
Showings allShowings;
@@ -298,7 +299,7 @@ Schedules::DoReschedule(const Ice::Current & ice)
}
void
-Schedules::DeleteSchedule(int id, const Ice::Current & ice)
+SchedulesI::DeleteSchedule(int id, const Ice::Current & ice)
{
auto dbc = db->get();
auto del = P2PVR::sql::schedules::deleteById.modify(dbc.get());
@@ -308,14 +309,14 @@ Schedules::DeleteSchedule(int id, const Ice::Current & ice)
}
P2PVR::ScheduleList
-Schedules::GetSchedules(const Ice::Current &)
+SchedulesI::GetSchedules(const Ice::Current &)
{
logger->message(LOG::DEBUG, __PRETTY_FUNCTION__);
return fetch<P2PVR::ScheduleList>(P2PVR::sql::schedules::selectAll);
}
P2PVR::SchedulePtr
-Schedules::GetSchedule(int id, const Ice::Current &)
+SchedulesI::GetSchedule(int id, const Ice::Current &)
{
logger->messagebf(LOG::DEBUG, "%s(%d)", __PRETTY_FUNCTION__, id);
auto schedules = fetch<P2PVR::ScheduleList>(P2PVR::sql::schedules::selectById, id);
@@ -324,14 +325,14 @@ Schedules::GetSchedule(int id, const Ice::Current &)
}
P2PVR::ScheduledToRecordList
-Schedules::GetScheduledToRecord(const Ice::Current &)
+SchedulesI::GetScheduledToRecord(const Ice::Current &)
{
logger->message(LOG::DEBUG, __PRETTY_FUNCTION__);
return fetch<P2PVR::ScheduledToRecordList>(P2PVR::sql::schedules::scheduledToRecord);
}
Ice::Int
-Schedules::NewSchedule(const P2PVR::SchedulePtr & s, const Ice::Current & ice)
+SchedulesI::NewSchedule(const P2PVR::SchedulePtr & s, const Ice::Current & ice)
{
auto dbc = db->get();
Slicer::SerializeAny<Slicer::SqlFetchIdInsertSerializer>(s, dbc.get(), "schedules");
@@ -340,12 +341,13 @@ Schedules::NewSchedule(const P2PVR::SchedulePtr & s, const Ice::Current & ice)
}
void
-Schedules::UpdateSchedule(const P2PVR::SchedulePtr & s, const Ice::Current & ice)
+SchedulesI::UpdateSchedule(const P2PVR::SchedulePtr & s, const Ice::Current & ice)
{
auto dbc = db->get();
Slicer::SerializeAny<Slicer::SqlUpdateSerializer>(s, dbc.get(), "schedules");
DoReschedule(ice);
}
+}
-INSTANTIATEFACTORY(EpisodeGroup, const Episodes &);
+INSTANTIATEFACTORY(P2PVR::EpisodeGroup, const P2PVR::Episodes &);
diff --git a/p2pvr/daemon/schedules.h b/p2pvr/daemon/schedules.h
index 1acf69f..558c127 100644
--- a/p2pvr/daemon/schedules.h
+++ b/p2pvr/daemon/schedules.h
@@ -9,6 +9,7 @@
#include <intrusivePtrBase.h>
#include <logger.h>
+namespace P2PVR {
typedef boost::posix_time::ptime datetime;
class Episode;
@@ -64,7 +65,7 @@ class EpisodeGroup {
Showings selected;
};
-class DLL_PUBLIC Schedules : public P2PVR::Schedules, public IceTray::AbstractDatabaseClient {
+class DLL_PUBLIC SchedulesI : public Schedules, public IceTray::AbstractDatabaseClient {
public:
class Options : public IceTray::Options {
public:
@@ -75,14 +76,14 @@ class DLL_PUBLIC Schedules : public P2PVR::Schedules, public IceTray::AbstractDa
std::string SchedulerAlgorithm;
};
- Schedules(IceTray::DatabasePoolPtr);
+ SchedulesI(IceTray::DatabasePoolPtr);
void DeleteSchedule(int id, const Ice::Current &);
- P2PVR::SchedulePtr GetSchedule(int id, const Ice::Current &);
- P2PVR::ScheduleList GetSchedules(const Ice::Current &);
- P2PVR::ScheduledToRecordList GetScheduledToRecord(const Ice::Current &);
- Ice::Int NewSchedule(const P2PVR::SchedulePtr &, const Ice::Current &);
- void UpdateSchedule(const P2PVR::SchedulePtr &, const Ice::Current &);
+ SchedulePtr GetSchedule(int id, const Ice::Current &);
+ ScheduleList GetSchedules(const Ice::Current &);
+ ScheduledToRecordList GetScheduledToRecord(const Ice::Current &);
+ Ice::Int NewSchedule(const SchedulePtr &, const Ice::Current &);
+ void UpdateSchedule(const SchedulePtr &, const Ice::Current &);
void DoReschedule(const Ice::Current &);
protected:
@@ -95,6 +96,7 @@ class DLL_PUBLIC Schedules : public P2PVR::Schedules, public IceTray::AbstractDa
typedef AdHoc::Factory<EpisodeGroup, const Episodes &> EpisodeGroupFactory;
typedef boost::shared_ptr<EpisodeGroup> EpisodeGroupPtr;
+}
#endif
diff --git a/p2pvr/daemon/si.cpp b/p2pvr/daemon/si.cpp
index bee7fa7..f8a49be 100644
--- a/p2pvr/daemon/si.cpp
+++ b/p2pvr/daemon/si.cpp
@@ -21,47 +21,48 @@
#include "sql/si/eventsInRange.sql.h"
#include "sql/si/eventSearch.sql.h"
-IceTray::Logging::LoggerPtr SI::logger(LOGMANAGER()->getLogger<SI>());
+namespace P2PVR {
+IceTray::Logging::LoggerPtr SII::logger(LOGMANAGER()->getLogger<SII>());
-SI::SI(IceTray::DatabasePoolPtr db) :
+SII::SII(IceTray::DatabasePoolPtr db) :
IceTray::AbstractDatabaseClient(db)
{
}
DVBSI::Networks
-SI::GetNetworks(const Ice::Current &)
+SII::GetNetworks(const Ice::Current &)
{
logger->message(LOG::DEBUG, __PRETTY_FUNCTION__);
- return fetch<DVBSI::Networks>(P2PVR::sql::si::allNetworks);
+ return fetch<DVBSI::Networks>(sql::si::allNetworks);
}
-P2PVR::Deliveries
-SI::GetAllDeliveries(const Ice::Current &)
+Deliveries
+SII::GetAllDeliveries(const Ice::Current &)
{
logger->message(LOG::DEBUG, __PRETTY_FUNCTION__);
- auto rtn = fetch<P2PVR::Deliveries>("delivery_type", P2PVR::sql::si::allDeliveries);
+ auto rtn = fetch<Deliveries>("delivery_type", sql::si::allDeliveries);
logger->messagebf(LOG::DEBUG, "%s: Found %d delivery methods", __PRETTY_FUNCTION__, rtn.size());
return rtn;
}
DVBSI::DeliveryPtr
-SI::GetDeliveryForTransport(int id, const Ice::Current&)
+SII::GetDeliveryForTransport(int id, const Ice::Current&)
{
try {
logger->messagef(LOG::DEBUG, "%s(%d)", __PRETTY_FUNCTION__, id);
- return fetch<DVBSI::DeliveryPtr>("delivery_type", P2PVR::sql::si::deliveryForTransport, id);
+ return fetch<DVBSI::DeliveryPtr>("delivery_type", sql::si::deliveryForTransport, id);
}
catch (const Slicer::NoRowsReturned &) {
- throw P2PVR::NotFound();
+ throw NotFound();
}
}
DVBSI::DeliveryPtr
-SI::GetDeliveryForSi(const Ice::Current&)
+SII::GetDeliveryForSi(const Ice::Current&)
{
try {
logger->message(LOG::DEBUG, __PRETTY_FUNCTION__);
- return fetch<DVBSI::DeliveryPtr>("delivery_type", P2PVR::sql::si::serviceNextUsed);
+ return fetch<DVBSI::DeliveryPtr>("delivery_type", sql::si::serviceNextUsed);
}
catch (const Slicer::NoRowsReturned &) {
return NULL;
@@ -69,101 +70,89 @@ SI::GetDeliveryForSi(const Ice::Current&)
}
DVBSI::DeliveryPtr
-SI::GetDeliveryForService(int id, const Ice::Current&)
+SII::GetDeliveryForService(int id, const Ice::Current&)
{
try {
logger->messagef(LOG::DEBUG, "%s(%d)", __PRETTY_FUNCTION__, id);
- return fetch<DVBSI::DeliveryPtr>("delivery_type", P2PVR::sql::si::deliveryForService, id);
+ return fetch<DVBSI::DeliveryPtr>("delivery_type", sql::si::deliveryForService, id);
}
catch (const Slicer::NoRowsReturned &) {
- throw P2PVR::NotFound();
+ throw NotFound();
}
}
DVBSI::ServiceList
-SI::GetServices(const Ice::Current&)
+SII::GetServices(const Ice::Current&)
{
logger->message(LOG::DEBUG, __PRETTY_FUNCTION__);
- return fetch<DVBSI::ServiceList>(P2PVR::sql::si::servicesSelectAll);
+ return fetch<DVBSI::ServiceList>(sql::si::servicesSelectAll);
}
DVBSI::ServicePtr
-SI::GetService(int id, const Ice::Current&)
+SII::GetService(int id, const Ice::Current&)
{
logger->messagef(LOG::DEBUG, "%s(%d)", __PRETTY_FUNCTION__, id);
- auto rtn = fetch<DVBSI::ServiceList>(P2PVR::sql::si::servicesSelectById, id);
- if (rtn.empty()) throw P2PVR::NotFound();
+ auto rtn = fetch<DVBSI::ServiceList>(sql::si::servicesSelectById, id);
+ if (rtn.empty()) throw NotFound();
return rtn.front();
}
-P2PVR::Events
-SI::GetEvents(const P2PVR::IntSequence & eventUids, const Ice::Current &)
+Events
+SII::GetEvents(const IntSequence & eventUids, const Ice::Current &)
{
logger->message(LOG::DEBUG, __PRETTY_FUNCTION__);
- P2PVR::Events rtn;
+ Events rtn;
for (const auto & uid : eventUids) {
- auto list = fetch<P2PVR::Events>(P2PVR::sql::si::eventByUid, uid);
+ auto list = fetch<Events>(sql::si::eventByUid, uid);
std::copy(list.begin(), list.end(), std::back_inserter(rtn));
}
- if (rtn.size() != eventUids.size()) throw P2PVR::NotFound();
+ if (rtn.size() != eventUids.size()) throw NotFound();
return rtn;
}
-P2PVR::EventPtr
-SI::GetEvent(int serviceId, int eventId, const Ice::Current &)
+EventPtr
+SII::GetEvent(int serviceId, int eventId, const Ice::Current &)
{
logger->messagef(LOG::DEBUG, "%s(s=%d, e=%d)", __PRETTY_FUNCTION__, serviceId, eventId);
- auto rtn = fetch<P2PVR::Events>(P2PVR::sql::si::eventById, serviceId, eventId);
- if (rtn.empty()) throw P2PVR::NotFound();
+ auto rtn = fetch<Events>(sql::si::eventById, serviceId, eventId);
+ if (rtn.empty()) throw NotFound();
return rtn.front();
}
-P2PVR::Events
-SI::EventsOnNow(const Ice::Current &)
+Events
+SII::EventsOnNow(const Ice::Current &)
{
logger->message(LOG::DEBUG, __PRETTY_FUNCTION__);
- return fetch<P2PVR::Events>(P2PVR::sql::si::eventsOnNow);
+ return fetch<Events>(sql::si::eventsOnNow);
}
-namespace IceTray {
- template<>
- void
- AbstractDatabaseClient::bind1<Common::DateTime>(int x, DB::Command * cmd, const Common::DateTime &);
-}
-
-template<>
-void
-IceTray::AbstractDatabaseClient::bind1<Common::DateTime>(int x, DB::Command * cmd, const Common::DateTime & dt)
-{
- cmd->bindParamT(x, *dt);
-}
-
-P2PVR::Events
-SI::EventsInRange(const Common::DateTime & from, const Common::DateTime & to, const Ice::Current &)
+Events
+SII::EventsInRange(const Common::DateTime & from, const Common::DateTime & to, const Ice::Current &)
{
logger->messagebf(LOG::DEBUG, "%s([%s]-[%s])", from, to, __PRETTY_FUNCTION__);
- return fetch<P2PVR::Events>(P2PVR::sql::si::eventsInRange, from, to);
+ return fetch<Events>(sql::si::eventsInRange, from, to);
}
-P2PVR::Events
-SI::EventSearch(const IceUtil::Optional<std::string> & keywords, const IceUtil::Optional<Ice::Int> & serviceId, const IceUtil::Optional<Common::DateTime> & from, const IceUtil::Optional<Common::DateTime> & to, const Ice::Current &)
+Events
+SII::EventSearch(const IceUtil::Optional<std::string> & keywords, const IceUtil::Optional<Ice::Int> & serviceId, const IceUtil::Optional<Common::DateTime> & from, const IceUtil::Optional<Common::DateTime> & to, const Ice::Current &)
{
logger->messagebf(LOG::DEBUG, "%s(keywords=%s,serviceId=%s,from=%s,to=%s)",
keywords, serviceId, from, to, __PRETTY_FUNCTION__);
- return fetch<P2PVR::Events>(P2PVR::sql::si::eventSearch, from, to, serviceId, serviceId, keywords, keywords, keywords, keywords);
+ return fetch<Events>(sql::si::eventSearch, from, to, serviceId, serviceId, keywords, keywords, keywords, keywords);
}
-P2PVR::Events
-SI::EventsInSchedules(const Ice::Current &)
+Events
+SII::EventsInSchedules(const Ice::Current &)
{
logger->message(LOG::DEBUG, __PRETTY_FUNCTION__);
- return fetch<P2PVR::Events>(P2PVR::sql::si::eventsInSchedules);
+ return fetch<Events>(sql::si::eventsInSchedules);
}
-P2PVR::Events
-SI::EventsInSchedule(int scheduleId, const Ice::Current &)
+Events
+SII::EventsInSchedule(int scheduleId, const Ice::Current &)
{
logger->messagebf(LOG::DEBUG, "%s(%d)", scheduleId, __PRETTY_FUNCTION__);
- return fetch<P2PVR::Events>(P2PVR::sql::si::eventsInSchedule, scheduleId);
+ return fetch<Events>(sql::si::eventsInSchedule, scheduleId);
+}
}
diff --git a/p2pvr/daemon/si.h b/p2pvr/daemon/si.h
index c9080ab..4ee7629 100644
--- a/p2pvr/daemon/si.h
+++ b/p2pvr/daemon/si.h
@@ -6,12 +6,13 @@
#include <visibility.h>
#include <logger.h>
-class DLL_PUBLIC SI : public P2PVR::SI, public IceTray::AbstractDatabaseClient {
+namespace P2PVR {
+class DLL_PUBLIC SII : public SI, public IceTray::AbstractDatabaseClient {
public:
- SI(IceTray::DatabasePoolPtr);
+ SII(IceTray::DatabasePoolPtr);
DVBSI::Networks GetNetworks(const Ice::Current &);
- P2PVR::Deliveries GetAllDeliveries(const Ice::Current &);
+ Deliveries GetAllDeliveries(const Ice::Current &);
DVBSI::DeliveryPtr GetDeliveryForService(int id, const Ice::Current &);
DVBSI::DeliveryPtr GetDeliveryForTransport(int id, const Ice::Current &);
DVBSI::DeliveryPtr GetDeliveryForSi(const Ice::Current &);
@@ -19,16 +20,17 @@ class DLL_PUBLIC SI : public P2PVR::SI, public IceTray::AbstractDatabaseClient {
DVBSI::ServiceList GetServices(const Ice::Current &);
DVBSI::ServicePtr GetService(int id, const Ice::Current &);
- P2PVR::Events GetEvents(const P2PVR::IntSequence & eventUids, const Ice::Current &);
- P2PVR::EventPtr GetEvent(int serviceId, int eventId, const Ice::Current &);
- P2PVR::Events EventsOnNow(const Ice::Current &);
- P2PVR::Events EventsInSchedules(const Ice::Current &);
- P2PVR::Events EventsInSchedule(int scheduleId, const Ice::Current &);
- P2PVR::Events EventsInRange(const Common::DateTime &, const Common::DateTime &, const Ice::Current &);
- P2PVR::Events EventSearch(const IceUtil::Optional<std::string> & keywords, const IceUtil::Optional<Ice::Int> & serviceId, const IceUtil::Optional<Common::DateTime> & from, const IceUtil::Optional<Common::DateTime> & to, const Ice::Current &);
+ Events GetEvents(const IntSequence & eventUids, const Ice::Current &);
+ EventPtr GetEvent(int serviceId, int eventId, const Ice::Current &);
+ Events EventsOnNow(const Ice::Current &);
+ Events EventsInSchedules(const Ice::Current &);
+ Events EventsInSchedule(int scheduleId, const Ice::Current &);
+ Events EventsInRange(const Common::DateTime &, const Common::DateTime &, const Ice::Current &);
+ Events EventSearch(const IceUtil::Optional<std::string> & keywords, const IceUtil::Optional<Ice::Int> & serviceId, const IceUtil::Optional<Common::DateTime> & from, const IceUtil::Optional<Common::DateTime> & to, const Ice::Current &);
static IceTray::Logging::LoggerPtr logger;
};
+}
#endif
diff --git a/p2pvr/daemon/storage.cpp b/p2pvr/daemon/storage.cpp
index e443699..51c1924 100644
--- a/p2pvr/daemon/storage.cpp
+++ b/p2pvr/daemon/storage.cpp
@@ -8,32 +8,33 @@
namespace fs = boost::filesystem;
namespace po = boost::program_options;
-Storage::Options::Options() :
+namespace P2PVR {
+StorageI::Options::Options() :
IceTray::Options("P2PVR Storage options")
{
}
-ICETRAY_OPTIONS(Storage::Options,
+ICETRAY_OPTIONS(StorageI::Options,
("p2pvr.storage.muxercommand", po::value(&muxerCommand)->default_value("/usr/bin/ffmpeg -i - -f mp4 -y ${TARGET}"),
"Command to perform TS->PS muxing (default: '/usr/bin/ffmpeg -i - -f mp4 -y ${TARGET}')")
("p2pvr.storage.root", po::value(&root)->default_value("recordings"),
"Root folder in which to store recordings")
);
-IceTray::Logging::LoggerPtr Storage::logger(LOGMANAGER()->getLogger<Storage>());
+IceTray::Logging::LoggerPtr StorageI::logger(LOGMANAGER()->getLogger<StorageI>());
-P2PVR::RawDataClientPrx
-Storage::OpenForWrite(const std::string & id, const Ice::Current & ice)
+RawDataClientPrx
+StorageI::OpenForWrite(const std::string & id, const Ice::Current & ice)
{
fs::create_directories(options->root);
fs::path path = options->root / id;
- P2PVR::RawDataClient * target;
+ RawDataClient * target;
if (options->muxerCommand.empty()) {
auto fd = open(path.string().c_str(), O_WRONLY | O_CREAT | O_EXCL, 0664);
if (fd < 0) {
logger->messagebf(LOG::ERR, "%s: Failed to open file for reading at %s (%d:%s)", __PRETTY_FUNCTION__,
path, errno, strerror(errno));
- throw P2PVR::StorageException(path.string(), strerror(errno));
+ throw StorageException(path.string(), strerror(errno));
}
target = new FileSink(fd);
}
@@ -46,13 +47,13 @@ Storage::OpenForWrite(const std::string & id, const Ice::Current & ice)
}
void
-Storage::Close(const P2PVR::RawDataClientPrx & file, const Ice::Current &)
+StorageI::Close(const RawDataClientPrx & file, const Ice::Current &)
{
openFiles.erase(std::find_if(openFiles.begin(), openFiles.end(), [&file](const OpenFilePtr & of) { return *of == file; }));
}
void
-Storage::Delete(const std::string & id, const Ice::Current &)
+StorageI::Delete(const std::string & id, const Ice::Current &)
{
fs::path path = options->root / id;
logger->messagebf(LOG::INFO, "%s: Deleting %s", __PRETTY_FUNCTION__, path);
@@ -60,25 +61,25 @@ Storage::Delete(const std::string & id, const Ice::Current &)
}
void
-Storage::Send(const std::string & id, const P2PVR::RawDataClientPrx & target, Ice::Long start, Ice::Long len, const Ice::Current &)
+StorageI::Send(const std::string & id, const RawDataClientPrx & target, Ice::Long start, Ice::Long len, const Ice::Current &)
{
fs::path path = options->root / id;
auto fd = open(path.string().c_str(), O_RDONLY | O_LARGEFILE);
if (fd < 0) {
logger->messagebf(LOG::ERR, "%s: Failed to open file for reading at %s (%d:%s)", __PRETTY_FUNCTION__,
path, errno, strerror(errno));
- throw P2PVR::StorageException(path.string(), strerror(errno));
+ throw StorageException(path.string(), strerror(errno));
}
lseek(fd, start, SEEK_SET);
auto end = std::min<off_t>(fs::file_size(path), start + len);
while (start < end) {
- P2PVR::Data buf(16 * 1024);
+ Data buf(16 * 1024);
auto r = read(fd, &buf.front(), std::min<size_t>(buf.size(), end - start));
if (r < 0) {
logger->messagebf(LOG::ERR, "%s: Failed to read file %s (%d:%s)", __PRETTY_FUNCTION__,
path, errno, strerror(errno));
close(fd);
- throw P2PVR::StorageException(path.string(), strerror(errno));
+ throw StorageException(path.string(), strerror(errno));
}
if (target->NewData(buf)) {
close(fd);
@@ -90,14 +91,15 @@ Storage::Send(const std::string & id, const P2PVR::RawDataClientPrx & target, Ic
}
Ice::Long
-Storage::FileSize(const std::string & id, const Ice::Current &)
+StorageI::FileSize(const std::string & id, const Ice::Current &)
{
fs::path path = options->root / id;
try {
return fs::file_size(path);
}
catch (...) {
- throw P2PVR::StorageException(path.string(), "Couldn't get file size");
+ throw StorageException(path.string(), "Couldn't get file size");
}
}
+}
diff --git a/p2pvr/daemon/storage.h b/p2pvr/daemon/storage.h
index d66a5d3..4a2b389 100644
--- a/p2pvr/daemon/storage.h
+++ b/p2pvr/daemon/storage.h
@@ -10,7 +10,8 @@
#include <visibility.h>
#include <logger.h>
-class DLL_PUBLIC Storage : public P2PVR::Storage {
+namespace P2PVR {
+class DLL_PUBLIC StorageI : public Storage {
public:
class Options : public IceTray::Options {
public:
@@ -22,19 +23,20 @@ class DLL_PUBLIC Storage : public P2PVR::Storage {
boost::filesystem::path root;
};
- P2PVR::RawDataClientPrx OpenForWrite(const std::string &, const Ice::Current &) override;
- void Close(const P2PVR::RawDataClientPrx & file, const Ice::Current &) override;
+ RawDataClientPrx OpenForWrite(const std::string &, const Ice::Current &) override;
+ void Close(const RawDataClientPrx & file, const Ice::Current &) override;
void Delete(const std::string &, const Ice::Current &) override;
Ice::Long FileSize(const std::string &, const Ice::Current &) override;
- void Send(const std::string &, const P2PVR::RawDataClientPrx & target, Ice::Long start, Ice::Long len, const Ice::Current &) override;
+ void Send(const std::string &, const RawDataClientPrx & target, Ice::Long start, Ice::Long len, const Ice::Current &) override;
protected:
- typedef TemporaryIceAdapterObject<P2PVR::RawDataClient> OpenFile;
+ typedef TemporaryIceAdapterObject<RawDataClient> OpenFile;
typedef boost::shared_ptr<OpenFile> OpenFilePtr;
typedef std::set<OpenFilePtr> OpenFiles;
OpenFiles openFiles;
IceTray::OptionsResolver<Options> options;
static IceTray::Logging::LoggerPtr logger;
};
+}
#endif
diff --git a/p2pvr/daemon/unittests/mockDefs.cpp b/p2pvr/daemon/unittests/mockDefs.cpp
index d810719..49066da 100644
--- a/p2pvr/daemon/unittests/mockDefs.cpp
+++ b/p2pvr/daemon/unittests/mockDefs.cpp
@@ -1,6 +1,8 @@
#include "mockDefs.h"
#include <definedDirs.h>
+namespace P2PVR {
+namespace Testing {
SchemaOnlyMockDatabase::SchemaOnlyMockDatabase() :
PQ::Mock("user=postgres dbname=postgres", "postgres", {
rootDir.parent_path().parent_path() / "datasources" / "schema.sql" })
@@ -23,14 +25,16 @@ StandardMockDatabasePlusOffset::StandardMockDatabasePlusOffset() :
}
TestClient::TestClient() :
- localDevices(getProxy<P2PVR::LocalDevicesPrx>("Devices")),
- devices(getProxy<P2PVR::DevicesPrx>("GlobalDevices")),
- maint(getProxy<P2PVR::MaintenancePrx>("Maintenance")),
- si(getProxy<P2PVR::SIPrx>("SI")),
- schedules(getProxy<P2PVR::SchedulesPrx>("Schedules")),
- storage(getProxy<P2PVR::StoragePrx>("Storage")),
- recorder(getProxy<P2PVR::RecorderPrx>("Recorder")),
- recordings(getProxy<P2PVR::RecordingsPrx>("Recordings"))
+ localDevices(getProxy<LocalDevicesPrx>("Devices")),
+ devices(getProxy<DevicesPrx>("GlobalDevices")),
+ maint(getProxy<MaintenancePrx>("Maintenance")),
+ si(getProxy<SIPrx>("SI")),
+ schedules(getProxy<SchedulesPrx>("Schedules")),
+ storage(getProxy<StoragePrx>("Storage")),
+ recorder(getProxy<RecorderPrx>("Recorder")),
+ recordings(getProxy<RecordingsPrx>("Recordings"))
{
}
+}
+}
diff --git a/p2pvr/daemon/unittests/mockDefs.h b/p2pvr/daemon/unittests/mockDefs.h
index 6675c2f..2874ef1 100644
--- a/p2pvr/daemon/unittests/mockDefs.h
+++ b/p2pvr/daemon/unittests/mockDefs.h
@@ -6,6 +6,8 @@
#include <dryice.h>
#include <p2pvr.h>
+namespace P2PVR {
+namespace Testing {
#define DECLAREMOCK(Name) class DLL_PUBLIC Name : public PQ::Mock, public IceTray::DryIce { public: Name(); }
DECLAREMOCK(SchemaOnlyMockDatabase);
@@ -18,15 +20,17 @@ class DLL_PUBLIC TestClient : public IceTray::DryIceClient {
public:
TestClient();
- P2PVR::LocalDevicesPrx localDevices;
- P2PVR::DevicesPrx devices;
- P2PVR::MaintenancePrx maint;
- P2PVR::SIPrx si;
- P2PVR::SchedulesPrx schedules;
- P2PVR::StoragePrx storage;
- P2PVR::RecorderPrx recorder;
- P2PVR::RecordingsPrx recordings;
+ LocalDevicesPrx localDevices;
+ DevicesPrx devices;
+ MaintenancePrx maint;
+ SIPrx si;
+ SchedulesPrx schedules;
+ StoragePrx storage;
+ RecorderPrx recorder;
+ RecordingsPrx recordings;
};
+}
+}
#endif
diff --git a/p2pvr/daemon/unittests/mockDevices.cpp b/p2pvr/daemon/unittests/mockDevices.cpp
index 777d5d3..f0ec930 100644
--- a/p2pvr/daemon/unittests/mockDevices.cpp
+++ b/p2pvr/daemon/unittests/mockDevices.cpp
@@ -2,22 +2,24 @@
#include <mockTuner.h>
#include <Ice/ObjectAdapter.h>
-P2PVR::TunerPrx MockDevices::GetTunerSpecific(const DVBSI::DeliveryPtr&, const Ice::Current & ice)
+namespace P2PVR {
+namespace Testing {
+TunerPrx MockDevices::GetTunerSpecific(const DVBSI::DeliveryPtr&, const Ice::Current & ice)
{
- return P2PVR::PrivateTunerPrx::checkedCast(ice.adapter->addWithUUID(new MockTuner()));
+ return PrivateTunerPrx::checkedCast(ice.adapter->addWithUUID(new MockTuner()));
}
-P2PVR::TunerPrx MockDevices::GetTunerAny(const DVBSI::DeliveryPtr&, const Ice::Current & ice)
+TunerPrx MockDevices::GetTunerAny(const DVBSI::DeliveryPtr&, const Ice::Current & ice)
{
- return P2PVR::PrivateTunerPrx::checkedCast(ice.adapter->addWithUUID(new MockTuner()));
+ return PrivateTunerPrx::checkedCast(ice.adapter->addWithUUID(new MockTuner()));
}
-P2PVR::PrivateTunerPrx MockDevices::GetPrivateTuner(Ice::Short, const Ice::Current & ice)
+PrivateTunerPrx MockDevices::GetPrivateTuner(Ice::Short, const Ice::Current & ice)
{
- return P2PVR::PrivateTunerPrx::checkedCast(ice.adapter->addWithUUID(new MockTuner()));
+ return PrivateTunerPrx::checkedCast(ice.adapter->addWithUUID(new MockTuner()));
}
-void MockDevices::ReleaseTuner(const P2PVR::TunerPrx & tuner, const Ice::Current & ice)
+void MockDevices::ReleaseTuner(const TunerPrx & tuner, const Ice::Current & ice)
{
ice.adapter->remove(tuner->ice_getIdentity());
}
@@ -26,4 +28,6 @@ Ice::Int MockDevices::TunerCount(const Ice::Current&)
{
return 1;
}
+}
+}
diff --git a/p2pvr/daemon/unittests/mockDevices.h b/p2pvr/daemon/unittests/mockDevices.h
index f6e4c43..be04772 100644
--- a/p2pvr/daemon/unittests/mockDevices.h
+++ b/p2pvr/daemon/unittests/mockDevices.h
@@ -4,14 +4,18 @@
#include <dvb.h>
#include <visibility.h>
-class DLL_PUBLIC MockDevices : public P2PVR::Devices {
+namespace P2PVR {
+namespace Testing {
+class DLL_PUBLIC MockDevices : public Devices {
public:
- P2PVR::TunerPrx GetTunerSpecific(const DVBSI::DeliveryPtr&, const Ice::Current & ice) override;
- P2PVR::TunerPrx GetTunerAny(const DVBSI::DeliveryPtr&, const Ice::Current & ice) override;
- P2PVR::PrivateTunerPrx GetPrivateTuner(Ice::Short, const Ice::Current & ice) override;
- void ReleaseTuner(const P2PVR::TunerPrx & tuner, const Ice::Current & ice) override;
+ TunerPrx GetTunerSpecific(const DVBSI::DeliveryPtr&, const Ice::Current & ice) override;
+ TunerPrx GetTunerAny(const DVBSI::DeliveryPtr&, const Ice::Current & ice) override;
+ PrivateTunerPrx GetPrivateTuner(Ice::Short, const Ice::Current & ice) override;
+ void ReleaseTuner(const TunerPrx & tuner, const Ice::Current & ice) override;
Ice::Int TunerCount(const Ice::Current&) override;
};
+}
+}
#endif
diff --git a/p2pvr/daemon/unittests/mockRecorder.cpp b/p2pvr/daemon/unittests/mockRecorder.cpp
index 0796aba..0420e69 100644
--- a/p2pvr/daemon/unittests/mockRecorder.cpp
+++ b/p2pvr/daemon/unittests/mockRecorder.cpp
@@ -1,8 +1,11 @@
#include "mockRecorder.h"
+namespace P2PVR {
+namespace Testing {
void
MockRecorder::RefreshSchedules(const Ice::Current &)
{
-
+}
+}
}
diff --git a/p2pvr/daemon/unittests/mockRecorder.h b/p2pvr/daemon/unittests/mockRecorder.h
index d76904d..b52020b 100644
--- a/p2pvr/daemon/unittests/mockRecorder.h
+++ b/p2pvr/daemon/unittests/mockRecorder.h
@@ -4,10 +4,14 @@
#include <p2pvr.h>
#include <visibility.h>
-class DLL_PUBLIC MockRecorder : public P2PVR::Recorder {
+namespace P2PVR {
+namespace Testing {
+class DLL_PUBLIC MockRecorder : public Recorder {
public:
void RefreshSchedules(const Ice::Current &) override;
};
+}
+}
#endif
diff --git a/p2pvr/daemon/unittests/mockScheduler.cpp b/p2pvr/daemon/unittests/mockScheduler.cpp
index 193630d..b19673c 100644
--- a/p2pvr/daemon/unittests/mockScheduler.cpp
+++ b/p2pvr/daemon/unittests/mockScheduler.cpp
@@ -1,5 +1,7 @@
#include "mockScheduler.h"
+namespace P2PVR {
+namespace Testing {
void
MockScheduler::DoReschedule(const::Ice::Current &)
{
@@ -38,4 +40,6 @@ void
MockScheduler::UpdateSchedule(const::P2PVR::SchedulePtr &, const::Ice::Current &)
{
}
+}
+}
diff --git a/p2pvr/daemon/unittests/mockScheduler.h b/p2pvr/daemon/unittests/mockScheduler.h
index c3640f6..f718363 100644
--- a/p2pvr/daemon/unittests/mockScheduler.h
+++ b/p2pvr/daemon/unittests/mockScheduler.h
@@ -4,16 +4,20 @@
#include <p2pvr.h>
#include <visibility.h>
-class DLL_PUBLIC MockScheduler : public P2PVR::Schedules {
+namespace P2PVR {
+namespace Testing {
+class DLL_PUBLIC MockScheduler : public Schedules {
public:
void DoReschedule(const ::Ice::Current&) override;
void DeleteSchedule(Ice::Int, const Ice::Current&) override;
- P2PVR::SchedulePtr GetSchedule(::Ice::Int, const ::Ice::Current&) override;
- P2PVR::ScheduleList GetSchedules(const ::Ice::Current&) override;
- P2PVR::ScheduledToRecordList GetScheduledToRecord(const ::Ice::Current&) override;
- Ice::Int NewSchedule(const ::P2PVR::SchedulePtr&, const ::Ice::Current&) override;
- void UpdateSchedule(const ::P2PVR::SchedulePtr&, const ::Ice::Current&) override;
+ SchedulePtr GetSchedule(::Ice::Int, const ::Ice::Current&) override;
+ ScheduleList GetSchedules(const ::Ice::Current&) override;
+ ScheduledToRecordList GetScheduledToRecord(const ::Ice::Current&) override;
+ Ice::Int NewSchedule(const SchedulePtr&, const ::Ice::Current&) override;
+ void UpdateSchedule(const SchedulePtr&, const ::Ice::Current&) override;
};
+}
+}
#endif
diff --git a/p2pvr/daemon/unittests/testErrorHandling.cpp b/p2pvr/daemon/unittests/testErrorHandling.cpp
index b04c78c..3758aff 100644
--- a/p2pvr/daemon/unittests/testErrorHandling.cpp
+++ b/p2pvr/daemon/unittests/testErrorHandling.cpp
@@ -16,6 +16,12 @@
#include <temporaryIceAdapterObject.h>
#include "mockDefs.h"
+using namespace P2PVR;
+using namespace P2PVR::Testing;
+using namespace P2PVR::DVBSI;
+
+namespace P2PVR {
+namespace Testing {
class Core : public StandardMockDatabase {
public:
Core()
@@ -24,25 +30,25 @@ class Core : public StandardMockDatabase {
}
};
-class TestDataClient : public P2PVR::RawDataClient {
+class TestDataClient : public RawDataClient {
public:
- virtual bool NewData(const P2PVR::Data &, const Ice::Current &) override
+ virtual bool NewData(const Data &, const Ice::Current &) override
{
return false;
}
};
-class FailingTestClient : public P2PVR::RawDataClient {
+class FailingTestClient : public RawDataClient {
public:
- bool NewData(const P2PVR::Data &, const Ice::Current &) override
+ bool NewData(const Data &, const Ice::Current &) override
{
- throw P2PVR::DataHandlingException();
+ throw DataHandlingException();
}
};
class TestNetworkParser : public SiNetworkInformationParser {
public:
- bool HandleTable(DVBSI::NetworkPtr) override
+ bool HandleTable(::DVBSI::NetworkPtr) override
{
return false;
}
@@ -50,11 +56,13 @@ class TestNetworkParser : public SiNetworkInformationParser {
class FailingTestNetworkParser : public SiNetworkInformationParser {
public:
- bool HandleTable(DVBSI::NetworkPtr) override
+ bool HandleTable(::DVBSI::NetworkPtr) override
{
- throw P2PVR::DataHandlingException();
+ throw DataHandlingException();
}
};
+}
+}
BOOST_GLOBAL_FIXTURE( Core );
@@ -65,7 +73,7 @@ BOOST_AUTO_TEST_CASE(TestRawDataClient)
BOOST_TEST_CHECKPOINT("Setup");
auto del = si->GetDeliveryForSi();
auto gd = devices->GetTunerAny(del);
- TemporaryIceAdapterObject<P2PVR::RawDataClient> a(getAdapter(), new TestDataClient());
+ TemporaryIceAdapterObject<RawDataClient> a(getAdapter(), new TestDataClient());
BOOST_TEST_CHECKPOINT("Make successful call");
gd->SendNetworkInformation(a);
}
@@ -75,7 +83,7 @@ BOOST_AUTO_TEST_CASE(TestParser)
BOOST_TEST_CHECKPOINT("Setup");
auto del = si->GetDeliveryForSi();
auto gd = devices->GetTunerAny(del);
- TemporaryIceAdapterObject<P2PVR::RawDataClient> a(getAdapter(), new TestNetworkParser());
+ TemporaryIceAdapterObject<RawDataClient> a(getAdapter(), new TestNetworkParser());
BOOST_TEST_CHECKPOINT("Make successful call");
gd->SendNetworkInformation(a);
}
@@ -85,9 +93,9 @@ BOOST_AUTO_TEST_CASE(TestRawDataClientWithError)
BOOST_TEST_CHECKPOINT("Setup");
auto del = si->GetDeliveryForSi();
auto gd = devices->GetTunerAny(del);
- TemporaryIceAdapterObject<P2PVR::RawDataClient> a(getAdapter(), new FailingTestClient());
+ TemporaryIceAdapterObject<RawDataClient> a(getAdapter(), new FailingTestClient());
BOOST_TEST_CHECKPOINT("Make failing call");
- BOOST_REQUIRE_THROW(gd->SendNetworkInformation(a), P2PVR::DataHandlingException);
+ BOOST_REQUIRE_THROW(gd->SendNetworkInformation(a), DataHandlingException);
}
BOOST_AUTO_TEST_CASE(TestParserWithError)
@@ -95,9 +103,9 @@ BOOST_AUTO_TEST_CASE(TestParserWithError)
BOOST_TEST_CHECKPOINT("Setup");
auto del = si->GetDeliveryForSi();
auto gd = devices->GetTunerAny(del);
- TemporaryIceAdapterObject<P2PVR::RawDataClient> a(getAdapter(), new FailingTestNetworkParser());
+ TemporaryIceAdapterObject<RawDataClient> a(getAdapter(), new FailingTestNetworkParser());
BOOST_TEST_CHECKPOINT("Make failing call");
- BOOST_REQUIRE_THROW(gd->SendNetworkInformation(a), P2PVR::DataHandlingException);
+ BOOST_REQUIRE_THROW(gd->SendNetworkInformation(a), DataHandlingException);
}
BOOST_AUTO_TEST_SUITE_END()
diff --git a/p2pvr/daemon/unittests/testMaint.cpp b/p2pvr/daemon/unittests/testMaint.cpp
index e02abae..10e0293 100644
--- a/p2pvr/daemon/unittests/testMaint.cpp
+++ b/p2pvr/daemon/unittests/testMaint.cpp
@@ -18,6 +18,11 @@
#include "commonHelpers.h"
#include <slicer/slicer.h>
+using namespace P2PVR;
+using namespace P2PVR::Testing;
+
+namespace P2PVR {
+namespace Testing {
class TestService : public SchemaOnlyMockDatabase {
public:
TestService()
@@ -26,6 +31,8 @@ class TestService : public SchemaOnlyMockDatabase {
replace("Schedules", new MockScheduler());
}
};
+}
+}
BOOST_GLOBAL_FIXTURE( TestService );
diff --git a/p2pvr/daemon/unittests/testRecording.cpp b/p2pvr/daemon/unittests/testRecording.cpp
index ca15447..e4dc6c1 100644
--- a/p2pvr/daemon/unittests/testRecording.cpp
+++ b/p2pvr/daemon/unittests/testRecording.cpp
@@ -19,6 +19,11 @@
#include "temporaryIceAdapterObject.h"
#include <slicer/slicer.h>
+using namespace P2PVR;
+using namespace P2PVR::Testing;
+
+namespace P2PVR {
+namespace Testing {
class TestService : public StandardMockDatabase {
public:
TestService()
@@ -28,11 +33,11 @@ class TestService : public StandardMockDatabase {
}
};
-class MockTarget : public P2PVR::RawDataClient {
+class MockTarget : public RawDataClient {
public:
MockTarget() : bytesReceived(0) { }
- bool NewData(const P2PVR::Data & data, const Ice::Current &) override
+ bool NewData(const Data & data, const Ice::Current &) override
{
bytesReceived += data.size();
return false;
@@ -40,6 +45,8 @@ class MockTarget : public P2PVR::RawDataClient {
unsigned int bytesReceived;
};
+}
+}
BOOST_GLOBAL_FIXTURE( TestService );
@@ -49,7 +56,7 @@ BOOST_AUTO_TEST_CASE( streamServiceToTarget )
{
BOOST_TEST_CHECKPOINT("Create mock target");
IceUtil::Handle<MockTarget> target = new MockTarget();
- TemporaryIceAdapterObject<P2PVR::RawDataClient> targetPrx(getAdapter(), target);
+ TemporaryIceAdapterObject<RawDataClient> targetPrx(getAdapter(), target);
BOOST_TEST_CHECKPOINT("Create service streamer");
auto ss = ServiceStreamerPtr(new ServiceStreamer(4170, targetPrx, devices, si, getAdapter()));
diff --git a/p2pvr/daemon/unittests/testRecordings.cpp b/p2pvr/daemon/unittests/testRecordings.cpp
index de28c8b..b12c984 100644
--- a/p2pvr/daemon/unittests/testRecordings.cpp
+++ b/p2pvr/daemon/unittests/testRecordings.cpp
@@ -15,6 +15,9 @@
#include <boost/lexical_cast.hpp>
#include "mockDefs.h"
+using namespace P2PVR;
+using namespace P2PVR::Testing;
+
BOOST_GLOBAL_FIXTURE( StandardMockDatabase );
BOOST_FIXTURE_TEST_SUITE( RecCore, TestClient )
diff --git a/p2pvr/daemon/unittests/testSched.cpp b/p2pvr/daemon/unittests/testSched.cpp
index aab5102..badf35c 100644
--- a/p2pvr/daemon/unittests/testSched.cpp
+++ b/p2pvr/daemon/unittests/testSched.cpp
@@ -17,6 +17,11 @@
#include <commonHelpers.h>
#include "mockDefs.h"
+using namespace P2PVR;
+using namespace P2PVR::Testing;
+
+namespace P2PVR {
+namespace Testing {
class TestService : public StandardMockDatabasePlusOffset {
public:
TestService()
@@ -25,6 +30,8 @@ class TestService : public StandardMockDatabasePlusOffset {
replace("Recorder", new MockRecorder());
}
};
+}
+}
BOOST_GLOBAL_FIXTURE( TestService );
diff --git a/p2pvr/daemon/unittests/testSi.cpp b/p2pvr/daemon/unittests/testSi.cpp
index 55998f9..73f92f3 100644
--- a/p2pvr/daemon/unittests/testSi.cpp
+++ b/p2pvr/daemon/unittests/testSi.cpp
@@ -14,6 +14,9 @@
#include <boost/lexical_cast.hpp>
#include "mockDefs.h"
+using namespace P2PVR;
+using namespace P2PVR::Testing;
+
BOOST_GLOBAL_FIXTURE( StandardMockDatabase );
BOOST_FIXTURE_TEST_SUITE( SiCore, TestClient )
diff --git a/p2pvr/daemon/unittests/testStorage.cpp b/p2pvr/daemon/unittests/testStorage.cpp
index 9e15662..ebbddcc 100644
--- a/p2pvr/daemon/unittests/testStorage.cpp
+++ b/p2pvr/daemon/unittests/testStorage.cpp
@@ -13,7 +13,12 @@
#include <definedDirs.h>
#include "mockDefs.h"
+using namespace P2PVR;
+using namespace P2PVR::Testing;
+
const boost::filesystem::path storageRootDir = "/tmp/ut/p2pvr/recordings";
+namespace P2PVR {
+namespace Testing {
class TestService : public PQ::Mock, public IceTray::DryIce {
public:
TestService() :
@@ -26,6 +31,8 @@ class TestService : public PQ::Mock, public IceTray::DryIce {
{
}
};
+}
+}
BOOST_GLOBAL_FIXTURE( TestService );
diff --git a/p2pvr/devices/frontend.cpp b/p2pvr/devices/frontend.cpp
index c1d2c61..c368fda 100644
--- a/p2pvr/devices/frontend.cpp
+++ b/p2pvr/devices/frontend.cpp
@@ -4,6 +4,8 @@
#include <linux/dvb/frontend.h>
#include <factory.impl.h>
+namespace P2PVR {
+namespace DVB {
Frontend::Frontend(Tuner * t, int fd, const struct dvb_frontend_info & i, IceTray::Logging::LoggerPtr log) :
tuner(t),
frontendFD(fd),
@@ -40,5 +42,7 @@ Frontend::FactoryKey(fe_type t)
return stringbf("Frontend:%x", t);
}
-INSTANTIATEFACTORY(Frontend, Tuner *, int, const struct dvb_frontend_info &);
+}
+}
+INSTANTIATEFACTORY(P2PVR::DVB::Frontend, P2PVR::DVB::Tuner *, int, const struct dvb_frontend_info &);
diff --git a/p2pvr/devices/frontend.h b/p2pvr/devices/frontend.h
index 51399b1..29180f4 100644
--- a/p2pvr/devices/frontend.h
+++ b/p2pvr/devices/frontend.h
@@ -6,6 +6,8 @@
#include <dvb.h>
#include <logger.h>
+namespace P2PVR {
+namespace DVB {
class Tuner;
class Frontend {
@@ -31,6 +33,8 @@ class Frontend {
typedef AdHoc::Factory<Frontend, Tuner *, int, const struct dvb_frontend_info &> FrontendFactory;
typedef boost::shared_ptr<Frontend> FrontendPtr;
+}
+}
#endif
diff --git a/p2pvr/devices/frontends/ofdm.cpp b/p2pvr/devices/frontends/ofdm.cpp
index caa42a6..15602eb 100644
--- a/p2pvr/devices/frontends/ofdm.cpp
+++ b/p2pvr/devices/frontends/ofdm.cpp
@@ -6,10 +6,13 @@
#define FREQ_OFFSET_MIN 0
#define FREQ_OFFSET_MAX 4
-class Frontend_OFDM : public Frontend {
+namespace P2PVR {
+namespace DVB {
+namespace Frontends {
+class OFDM : public Frontend {
public:
- Frontend_OFDM(Tuner * t, int fd, const struct dvb_frontend_info & i) :
- Frontend(t, fd, i, LOGMANAGER()->getLogger<Frontend_OFDM>())
+ OFDM(Tuner * t, int fd, const struct dvb_frontend_info & i) :
+ Frontend(t, fd, i, LOGMANAGER()->getLogger<OFDM>())
{
}
@@ -156,5 +159,8 @@ class Frontend_OFDM : public Frontend {
}
};
-NAMEDFACTORY(Frontend::FactoryKey(FE_OFDM), Frontend_OFDM, FrontendFactory);
+NAMEDFACTORY(Frontend::FactoryKey(FE_OFDM), OFDM, FrontendFactory);
+}
+}
+}
diff --git a/p2pvr/devices/localDevices.cpp b/p2pvr/devices/localDevices.cpp
index cbe74a8..ac13a29 100644
--- a/p2pvr/devices/localDevices.cpp
+++ b/p2pvr/devices/localDevices.cpp
@@ -3,23 +3,24 @@
#include "tuner.h"
#include "bindTimerTask.h"
-LocalDevices::Devices LocalDevices::devices;
-std::mutex LocalDevices::lock;
+namespace P2PVR {
+LocalDevicesI::Devices LocalDevicesI::devices;
+std::mutex LocalDevicesI::lock;
-LocalDevices::Options::Options() :
+LocalDevicesI::Options::Options() :
IceTray::Options("P2PVR Devices")
{
}
-ICETRAY_OPTIONS(LocalDevices::Options,
+ICETRAY_OPTIONS(LocalDevicesI::Options,
("p2pvr.localdevices.frontend", boost::program_options::value(&devices), "Frontend of DVB device(s) to use (/dev/dvb/adapterX/frontendY)")
);
-IceTray::Logging::LoggerPtr LocalDevices::logger(LOGMANAGER()->getLogger<LocalDevices>());
+IceTray::Logging::LoggerPtr LocalDevicesI::logger(LOGMANAGER()->getLogger<LocalDevicesI>());
-LocalDevices::LocalDevices(Ice::ObjectAdapterPtr adapter, IceUtil::TimerPtr t) :
+LocalDevicesI::LocalDevicesI(Ice::ObjectAdapterPtr adapter, IceUtil::TimerPtr t) :
timer(t),
- clientCheck(new BindTimerTask(boost::bind(&LocalDevices::ClientCheck, this, adapter)))
+ clientCheck(new BindTimerTask(boost::bind(&LocalDevicesI::ClientCheck, this, adapter)))
{
for (auto & device : options->devices) {
devices.insert({ device, nullptr });
@@ -28,14 +29,14 @@ LocalDevices::LocalDevices(Ice::ObjectAdapterPtr adapter, IceUtil::TimerPtr t) :
timer->scheduleRepeated(clientCheck, IceUtil::Time::seconds(30));
}
-LocalDevices::~LocalDevices()
+LocalDevicesI::~LocalDevicesI()
{
logger->message(LOG::DEBUG, __PRETTY_FUNCTION__);
timer->cancel(clientCheck);
}
void
-LocalDevices::ClientCheck(Ice::ObjectAdapterPtr adapter)
+LocalDevicesI::ClientCheck(Ice::ObjectAdapterPtr adapter)
{
std::lock_guard<std::mutex> g(lock);
for (auto & device : devices) {
@@ -50,8 +51,8 @@ LocalDevices::ClientCheck(Ice::ObjectAdapterPtr adapter)
}
}
-P2PVR::TunerPrx
-LocalDevices::GetTunerSpecific(const DVBSI::DeliveryPtr & delivery, const Ice::Current & ice)
+TunerPrx
+LocalDevicesI::GetTunerSpecific(const DVBSI::DeliveryPtr & delivery, const Ice::Current & ice)
{
std::lock_guard<std::mutex> g(lock);
logger->messagebf(LOG::DEBUG, "%s: Searching for an open sharable tuner (frequency %d)", __PRETTY_FUNCTION__, delivery->Frequency);
@@ -67,14 +68,14 @@ LocalDevices::GetTunerSpecific(const DVBSI::DeliveryPtr & delivery, const Ice::C
if (openTuner == devices.end()) {
logger->messagebf(LOG::DEBUG, "%s: None suitable and none free (frequency %d)",
__PRETTY_FUNCTION__, delivery->Frequency);
- throw P2PVR::NoSuitableDeviceAvailable();
+ throw NoSuitableDeviceAvailable();
}
logger->messagebf(LOG::DEBUG, "%s: Opening a sharable tuner (frequency %d, frontend %s)",
__PRETTY_FUNCTION__, delivery->Frequency, openTuner->first);
- P2PVR::PrivateTunerPtr t = new Tuner(openTuner->first);
+ PrivateTunerPtr t = new DVB::Tuner(openTuner->first);
t->TuneTo(delivery, ice);
- auto tuner = P2PVR::PrivateTunerPrx::checkedCast(ice.adapter->addWithUUID(t));
+ auto tuner = PrivateTunerPrx::checkedCast(ice.adapter->addWithUUID(t));
openTuner->second = OpenTunerPtr(new OpenTuner(delivery, tuner, false));
logger->messagebf(LOG::DEBUG, "%s: Tuned, returning (frequency %d, frontend %s)",
@@ -82,8 +83,8 @@ LocalDevices::GetTunerSpecific(const DVBSI::DeliveryPtr & delivery, const Ice::C
return tuner;
}
-P2PVR::TunerPrx
-LocalDevices::GetTunerAny(const DVBSI::DeliveryPtr & delivery, const Ice::Current & ice)
+TunerPrx
+LocalDevicesI::GetTunerAny(const DVBSI::DeliveryPtr & delivery, const Ice::Current & ice)
{
std::lock_guard<std::mutex> g(lock);
logger->messagebf(LOG::DEBUG, "%s: Searching for an open sharable tuner any frequency", __PRETTY_FUNCTION__);
@@ -99,14 +100,14 @@ LocalDevices::GetTunerAny(const DVBSI::DeliveryPtr & delivery, const Ice::Curren
if (openTuner == devices.end()) {
logger->messagebf(LOG::DEBUG, "%s: None suitable and none free (frequency %d)",
__PRETTY_FUNCTION__, delivery->Frequency);
- throw P2PVR::NoSuitableDeviceAvailable();
+ throw NoSuitableDeviceAvailable();
}
logger->messagebf(LOG::DEBUG, "%s: Opening a sharable tuner (frequency %d, frontend %s)",
__PRETTY_FUNCTION__, delivery->Frequency, openTuner->first);
- P2PVR::PrivateTunerPtr t = new Tuner(openTuner->first);
+ PrivateTunerPtr t = new DVB::Tuner(openTuner->first);
t->TuneTo(delivery, ice);
- auto tuner = P2PVR::PrivateTunerPrx::checkedCast(ice.adapter->addWithUUID(t));
+ auto tuner = PrivateTunerPrx::checkedCast(ice.adapter->addWithUUID(t));
openTuner->second = OpenTunerPtr(new OpenTuner(delivery, tuner, false));
logger->messagebf(LOG::DEBUG, "%s: Tuned, returning (frequency %d, frontend %s)",
@@ -114,27 +115,27 @@ LocalDevices::GetTunerAny(const DVBSI::DeliveryPtr & delivery, const Ice::Curren
return tuner;
}
-P2PVR::PrivateTunerPrx
-LocalDevices::GetPrivateTuner(short , const Ice::Current & ice)
+PrivateTunerPrx
+LocalDevicesI::GetPrivateTuner(short , const Ice::Current & ice)
{
std::lock_guard<std::mutex> g(lock);
logger->messagebf(LOG::DEBUG, "%s: Opening a private tuner", __PRETTY_FUNCTION__);
auto openTuner = std::find_if(devices.begin(), devices.end(), [](const Devices::value_type & ot) { return !ot.second; });
if (openTuner == devices.end()) {
logger->messagebf(LOG::DEBUG, "%s: None free", __PRETTY_FUNCTION__);
- throw P2PVR::NoSuitableDeviceAvailable();
+ throw NoSuitableDeviceAvailable();
}
logger->messagebf(LOG::DEBUG, "%s: Opening a private tuner (frontend %s)",
__PRETTY_FUNCTION__, openTuner->first);
- auto tuner = P2PVR::PrivateTunerPrx::checkedCast(ice.adapter->addWithUUID(new Tuner(openTuner->first)));
+ auto tuner = PrivateTunerPrx::checkedCast(ice.adapter->addWithUUID(new DVB::Tuner(openTuner->first)));
openTuner->second = OpenTunerPtr(new OpenTuner(NULL, tuner, true));
return tuner;
}
void
-LocalDevices::ReleaseTuner(const P2PVR::TunerPrx & tuner, const Ice::Current & ice)
+LocalDevicesI::ReleaseTuner(const TunerPrx & tuner, const Ice::Current & ice)
{
std::lock_guard<std::mutex> g(lock);
logger->messagebf(LOG::DEBUG, "%s", __PRETTY_FUNCTION__);
@@ -157,37 +158,38 @@ LocalDevices::ReleaseTuner(const P2PVR::TunerPrx & tuner, const Ice::Current & i
}
int
-LocalDevices::TunerCount(const Ice::Current &)
+LocalDevicesI::TunerCount(const Ice::Current &)
{
std::lock_guard<std::mutex> g(lock);
return devices.size();
}
void
-LocalDevices::Scan(const Ice::Current &)
+LocalDevicesI::Scan(const Ice::Current &)
{
std::lock_guard<std::mutex> g(lock);
}
void
-LocalDevices::Add(const std::string & frontend, const Ice::Current &)
+LocalDevicesI::Add(const std::string & frontend, const Ice::Current &)
{
std::lock_guard<std::mutex> g(lock);
devices.insert(Devices::value_type(frontend, OpenTunerPtr()));
}
void
-LocalDevices::Remove(const std::string & frontend, const Ice::Current &)
+LocalDevicesI::Remove(const std::string & frontend, const Ice::Current &)
{
std::lock_guard<std::mutex> g(lock);
devices.erase(frontend);
}
-LocalDevices::OpenTuner::OpenTuner(DVBSI::DeliveryPtr d, P2PVR::PrivateTunerPrx t, bool op) :
+LocalDevicesI::OpenTuner::OpenTuner(DVBSI::DeliveryPtr d, PrivateTunerPrx t, bool op) :
openedPrivate(op),
delivery(d),
tuner(t),
clients(1)
{
}
+}
diff --git a/p2pvr/devices/localDevices.h b/p2pvr/devices/localDevices.h
index 7bd97ee..0fd4ad2 100644
--- a/p2pvr/devices/localDevices.h
+++ b/p2pvr/devices/localDevices.h
@@ -1,7 +1,7 @@
#ifndef LOCALDEVICES_H
#define LOCALDEVICES_H
-// Local devices implements a device collection (P2PVR::Devices) for any devices physically
+// Local devices implements a device collection (Devices) for any devices physically
// attached to the local machine; that is, can be accessed directly through /dev/dvb/adapterX
#include <dvb.h>
@@ -11,7 +11,8 @@
#include <IceUtil/Timer.h>
#include <logger.h>
-class DLL_PUBLIC LocalDevices : public P2PVR::LocalDevices {
+namespace P2PVR {
+class DLL_PUBLIC LocalDevicesI : public LocalDevices {
public:
class Options : public IceTray::Options {
public:
@@ -22,13 +23,13 @@ class DLL_PUBLIC LocalDevices : public P2PVR::LocalDevices {
std::vector<std::string> devices;
};
- LocalDevices(Ice::ObjectAdapterPtr adapter, IceUtil::TimerPtr);
- ~LocalDevices();
+ LocalDevicesI(Ice::ObjectAdapterPtr adapter, IceUtil::TimerPtr);
+ ~LocalDevicesI();
- P2PVR::TunerPrx GetTunerSpecific(const DVBSI::DeliveryPtr &, const Ice::Current &);
- P2PVR::TunerPrx GetTunerAny(const DVBSI::DeliveryPtr &, const Ice::Current &);
- P2PVR::PrivateTunerPrx GetPrivateTuner(short type, const Ice::Current &);
- void ReleaseTuner(const P2PVR::TunerPrx &, const Ice::Current &);
+ TunerPrx GetTunerSpecific(const DVBSI::DeliveryPtr &, const Ice::Current &);
+ TunerPrx GetTunerAny(const DVBSI::DeliveryPtr &, const Ice::Current &);
+ PrivateTunerPrx GetPrivateTuner(short type, const Ice::Current &);
+ void ReleaseTuner(const TunerPrx &, const Ice::Current &);
int TunerCount(const Ice::Current &);
void Scan(const Ice::Current &);
@@ -45,11 +46,11 @@ class DLL_PUBLIC LocalDevices : public P2PVR::LocalDevices {
class DLL_PRIVATE OpenTuner {
public:
- OpenTuner(DVBSI::DeliveryPtr, P2PVR::PrivateTunerPrx, bool);
+ OpenTuner(DVBSI::DeliveryPtr, PrivateTunerPrx, bool);
const bool openedPrivate;
const DVBSI::DeliveryPtr delivery;
- const P2PVR::PrivateTunerPrx tuner;
+ const PrivateTunerPrx tuner;
unsigned int clients;
};
@@ -60,6 +61,7 @@ class DLL_PUBLIC LocalDevices : public P2PVR::LocalDevices {
static IceTray::Logging::LoggerPtr logger;
IceTray::OptionsResolver<Options> options;
};
+}
#endif
diff --git a/p2pvr/devices/mockTuner.cpp b/p2pvr/devices/mockTuner.cpp
index b040128..4430bc4 100644
--- a/p2pvr/devices/mockTuner.cpp
+++ b/p2pvr/devices/mockTuner.cpp
@@ -11,6 +11,8 @@ extern "C" { \
} \
static const Ice::ByteSeq resource(&resource##_start, &resource##_end);
+namespace P2PVR {
+namespace Testing {
void
MockTuner::LZMA_ASSERT(int ret_xz)
{
@@ -178,4 +180,6 @@ Ice::Long MockTuner::GetLastUsedTime(const Ice::Current&)
{
return time(NULL);
}
+}
+}
diff --git a/p2pvr/devices/mockTuner.h b/p2pvr/devices/mockTuner.h
index 60372c9..73ab27c 100644
--- a/p2pvr/devices/mockTuner.h
+++ b/p2pvr/devices/mockTuner.h
@@ -7,23 +7,25 @@
#include <boost/thread.hpp>
#include <logger.h>
-class DLL_PUBLIC MockTuner : public P2PVR::PrivateTuner {
+namespace P2PVR {
+namespace Testing {
+class DLL_PUBLIC MockTuner : public PrivateTuner {
public:
MockTuner();
void TuneTo(const DVBSI::DeliveryPtr &, const Ice::Current&);
int GetStatus(const Ice::Current&);
- void ScanAndSendNetworkInformation(const P2PVR::RawDataClientPrx & client, const Ice::Current&);
- void SendNetworkInformation(const P2PVR::RawDataClientPrx & client, const Ice::Current&);
- void SendBouquetAssociations(const P2PVR::RawDataClientPrx & client, const Ice::Current&);
- void SendServiceDescriptions(const P2PVR::RawDataClientPrx & client, const Ice::Current&);
- void SendProgramMap(Ice::Int pid, const P2PVR::RawDataClientPrx & client, const Ice::Current&);
- void SendProgramAssociationTable(const P2PVR::RawDataClientPrx & client, const Ice::Current&);
- void SendEventInformation(const P2PVR::RawDataClientPrx & client, const Ice::Current&);
+ void ScanAndSendNetworkInformation(const RawDataClientPrx & client, const Ice::Current&);
+ void SendNetworkInformation(const RawDataClientPrx & client, const Ice::Current&);
+ void SendBouquetAssociations(const RawDataClientPrx & client, const Ice::Current&);
+ void SendServiceDescriptions(const RawDataClientPrx & client, const Ice::Current&);
+ void SendProgramMap(Ice::Int pid, const RawDataClientPrx & client, const Ice::Current&);
+ void SendProgramAssociationTable(const RawDataClientPrx & client, const Ice::Current&);
+ void SendEventInformation(const RawDataClientPrx & client, const Ice::Current&);
- int StartSendingTS(const P2PVR::PacketIds & pids, const P2PVR::RawDataClientPrx & client, const Ice::Current &);
- int StartSendingSection(Ice::Int pid, const P2PVR::RawDataClientPrx & client, const Ice::Current &);
+ int StartSendingTS(const PacketIds & pids, const RawDataClientPrx & client, const Ice::Current &);
+ int StartSendingSection(Ice::Int pid, const RawDataClientPrx & client, const Ice::Current &);
void StopSending(int handle, const Ice::Current &);
Ice::Long GetLastUsedTime(const Ice::Current&);
@@ -33,8 +35,8 @@ class DLL_PUBLIC MockTuner : public P2PVR::PrivateTuner {
protected:
static Ice::ByteSeq Decompress(const Ice::ByteSeq &);
static void LZMA_ASSERT(int ret_xz);
- void DecompressAndSendPackets(const Ice::ByteSeq &, const P2PVR::RawDataClientPrx &, const Ice::Current&) const;
- void SendLoop(const P2PVR::RawDataClientPrx & t, const Ice::ByteSeq & dataxz, const Ice::Current & ice) const;
+ void DecompressAndSendPackets(const Ice::ByteSeq &, const RawDataClientPrx &, const Ice::Current&) const;
+ void SendLoop(const RawDataClientPrx & t, const Ice::ByteSeq & dataxz, const Ice::Current & ice) const;
static int eventSet;
std::map<int, boost::thread *> senders;
@@ -42,6 +44,8 @@ class DLL_PUBLIC MockTuner : public P2PVR::PrivateTuner {
static IceTray::Logging::LoggerPtr logger;
};
+}
+}
#endif
diff --git a/p2pvr/devices/tuner.cpp b/p2pvr/devices/tuner.cpp
index 148790b..f65fc32 100644
--- a/p2pvr/devices/tuner.cpp
+++ b/p2pvr/devices/tuner.cpp
@@ -12,6 +12,8 @@
#include "tunerSendSi.h"
#include "tunerSendTs.h"
+namespace P2PVR {
+namespace DVB {
IceTray::Logging::LoggerPtr Tuner::logger = LOGMANAGER()->getLogger<Tuner>();
Tuner::Tuner(const boost::filesystem::path & df) :
@@ -22,12 +24,12 @@ Tuner::Tuner(const boost::filesystem::path & df) :
{
int fd = open(deviceFrontend.string().c_str(), O_RDWR);
if (fd < 0) {
- throw P2PVR::DeviceError(deviceFrontend.string(), strerror(errno), errno);
+ throw DeviceError(deviceFrontend.string(), strerror(errno), errno);
}
try {
struct dvb_frontend_info fe_info;
if (ioctl(fd, FE_GET_INFO, &fe_info) < 0) {
- throw P2PVR::DeviceError(deviceFrontend.string(), strerror(errno), errno);
+ throw DeviceError(deviceFrontend.string(), strerror(errno), errno);
}
frontend = FrontendPtr(FrontendFactory::createNew(Frontend::FactoryKey(fe_info.type), this, fd, fe_info));
}
@@ -79,13 +81,13 @@ Tuner::OpenDemux() const
{
int demux = open((deviceRoot / "demux0").string().c_str(), O_RDWR | O_NONBLOCK);
if (demux < 0) {
- throw P2PVR::DeviceError(deviceRoot.string(), strerror(errno), errno);
+ throw DeviceError(deviceRoot.string(), strerror(errno), errno);
}
return demux;
}
void
-Tuner::ScanAndSendNetworkInformation(const P2PVR::RawDataClientPrx & client, const Ice::Current & ice)
+Tuner::ScanAndSendNetworkInformation(const RawDataClientPrx & client, const Ice::Current & ice)
{
time(&lastUsedTime);
frontend->FrequencyScan([this, &client, &ice](long) {
@@ -106,43 +108,43 @@ Tuner::ScanAndSendNetworkInformation(const P2PVR::RawDataClientPrx & client, con
}
void
-Tuner::SendNetworkInformation(const P2PVR::RawDataClientPrx & client, const Ice::Current & ice)
+Tuner::SendNetworkInformation(const RawDataClientPrx & client, const Ice::Current & ice)
{
SendPID(0x10, client, ice);
}
void
-Tuner::SendBouquetAssociations(const P2PVR::RawDataClientPrx & client, const Ice::Current & ice)
+Tuner::SendBouquetAssociations(const RawDataClientPrx & client, const Ice::Current & ice)
{
SendPID(0x11, client, ice);
}
void
-Tuner::SendServiceDescriptions(const P2PVR::RawDataClientPrx & client, const Ice::Current & ice)
+Tuner::SendServiceDescriptions(const RawDataClientPrx & client, const Ice::Current & ice)
{
SendPID(0x11, client, ice);
}
void
-Tuner::SendProgramMap(Ice::Int pid, const P2PVR::RawDataClientPrx & client, const Ice::Current & ice)
+Tuner::SendProgramMap(Ice::Int pid, const RawDataClientPrx & client, const Ice::Current & ice)
{
SendPID(pid, client, ice);
}
void
-Tuner::SendProgramAssociationTable(const P2PVR::RawDataClientPrx & client, const Ice::Current & ice)
+Tuner::SendProgramAssociationTable(const RawDataClientPrx & client, const Ice::Current & ice)
{
SendPID(0x00, client, ice);
}
void
-Tuner::SendEventInformation(const P2PVR::RawDataClientPrx & client, const Ice::Current & ice)
+Tuner::SendEventInformation(const RawDataClientPrx & client, const Ice::Current & ice)
{
SendPID(0x12, client, ice);
}
uint64_t
-Tuner::SendPID(int pid, const P2PVR::RawDataClientPrx & client, const Ice::Current & ice) const
+Tuner::SendPID(int pid, const RawDataClientPrx & client, const Ice::Current & ice) const
{
time(&lastUsedTime);
logger->messagebf(LOG::DEBUG, "%s: pid = 0x%x", __PRETTY_FUNCTION__, pid);
@@ -165,12 +167,12 @@ Tuner::RequestPID(int pid, int demux) const
sctFilterParams.flags = DMX_IMMEDIATE_START;
if (ioctl(demux, DMX_SET_FILTER, &sctFilterParams) < 0) {
- throw P2PVR::DeviceError("demux", strerror(errno), errno);
+ throw DeviceError("demux", strerror(errno), errno);
}
}
uint64_t
-Tuner::ReadDemuxAndSend(int demux, const P2PVR::RawDataClientPrx & _client) const
+Tuner::ReadDemuxAndSend(int demux, const RawDataClientPrx & _client) const
{
logger->messagebf(LOG::DEBUG, "%s: begin", __PRETTY_FUNCTION__);
struct pollfd ufd;
@@ -183,20 +185,20 @@ Tuner::ReadDemuxAndSend(int demux, const P2PVR::RawDataClientPrx & _client) cons
switch (poll(&ufd, 1, options->DemuxReadTimeout)) {
case -1:
logger->messagebf(LOG::DEBUG, "%s: poll error reading demux (%d:%s)", __PRETTY_FUNCTION__, errno, strerror(errno));
- throw P2PVR::DeviceError("demux", strerror(errno), errno);
+ throw DeviceError("demux", strerror(errno), errno);
case 0:
auto status = frontend->GetStatus();
logger->messagebf(LOG::DEBUG, "%s: Timed out waiting for data (device status 0x%02x)", __PRETTY_FUNCTION__, status);
- throw P2PVR::DeviceError("demux", "timeout", 0);
+ throw DeviceError("demux", "timeout", 0);
}
// Read it
- P2PVR::Data buf(1 << 12);
+ Data buf(1 << 12);
int nr = read(demux, &buf.front(), buf.size());
if (nr < 0) {
logger->messagebf(LOG::DEBUG, "%s: error reading demux (%d:%s) status 0x%02x",
__PRETTY_FUNCTION__, errno, strerror(errno), frontend->GetStatus());
- throw P2PVR::DeviceError("demux", strerror(errno), errno);
+ throw DeviceError("demux", strerror(errno), errno);
}
size_t n = nr;
buf.resize(n);
@@ -212,7 +214,7 @@ Tuner::ReadDemuxAndSend(int demux, const P2PVR::RawDataClientPrx & _client) cons
}
int
-Tuner::StartSendingSection(int pid, const P2PVR::RawDataClientPrx & client, const Ice::Current &)
+Tuner::StartSendingSection(int pid, const RawDataClientPrx & client, const Ice::Current &)
{
time(&lastUsedTime);
logger->message(LOG::DEBUG, __PRETTY_FUNCTION__);
@@ -226,12 +228,12 @@ Tuner::StartSendingSection(int pid, const P2PVR::RawDataClientPrx & client, cons
}
int
-Tuner::StartSendingTS(const P2PVR::PacketIds & pids, const P2PVR::RawDataClientPrx & client, const Ice::Current & ice)
+Tuner::StartSendingTS(const PacketIds & pids, const RawDataClientPrx & client, const Ice::Current & ice)
{
time(&lastUsedTime);
logger->message(LOG::DEBUG, __PRETTY_FUNCTION__);
if (pids.empty()) {
- throw P2PVR::DeviceError("demux", "Packet Id list cannot be empty", 0);
+ throw DeviceError("demux", "Packet Id list cannot be empty", 0);
}
if (ice.con) {
@@ -253,7 +255,7 @@ Tuner::StartSendingTS(const P2PVR::PacketIds & pids, const P2PVR::RawDataClientP
if (ioctl(demux, DMX_SET_PES_FILTER, &pesFilterParams) < 0) {
backgroundClients.erase(demux);
logger->messagebf(LOG::ERR, "%s: DMX_SET_PES_FILTER failed (%d: %s)", __PRETTY_FUNCTION__, errno, strerror(errno));
- throw P2PVR::DeviceError("demux", strerror(errno), errno);
+ throw DeviceError("demux", strerror(errno), errno);
}
for (unsigned int x = 1; x < pids.size(); x += 1) {
@@ -262,7 +264,7 @@ Tuner::StartSendingTS(const P2PVR::PacketIds & pids, const P2PVR::RawDataClientP
if (ioctl(demux, DMX_ADD_PID, &p) < 0) {
backgroundClients.erase(demux);
logger->messagebf(LOG::ERR, "%s: DMX_ADD_PID failed (%d: %s)", __PRETTY_FUNCTION__, errno, strerror(errno));
- throw P2PVR::DeviceError("demux", strerror(errno), errno);
+ throw DeviceError("demux", strerror(errno), errno);
}
}
@@ -270,7 +272,7 @@ Tuner::StartSendingTS(const P2PVR::PacketIds & pids, const P2PVR::RawDataClientP
if (ioctl(demux, DMX_START) < 0) {
backgroundClients.erase(demux);
logger->messagebf(LOG::ERR, "%s: DMX_START failed (%d: %s)", __PRETTY_FUNCTION__, errno, strerror(errno));
- throw P2PVR::DeviceError("demux", strerror(errno), errno);
+ throw DeviceError("demux", strerror(errno), errno);
}
startSenderThread();
@@ -282,7 +284,7 @@ Tuner::setBufferSize(int demux, unsigned long size)
{
if (ioctl(demux, DMX_SET_BUFFER_SIZE, size)) {
logger->messagebf(LOG::ERR, "%s: DMX_SET_BUFFER_SIZE to %d failed (%d: %s)", __PRETTY_FUNCTION__, size, errno, strerror(errno));
- throw P2PVR::DeviceError("demux", strerror(errno), errno);
+ throw DeviceError("demux", strerror(errno), errno);
}
logger->messagebf(LOG::DEBUG, "%s: DMX_SET_BUFFER_SIZE to %d", __PRETTY_FUNCTION__, size);
}
@@ -333,7 +335,7 @@ Tuner::senderThread()
for (auto c = backgroundClients.begin(); c != backgroundClients.end(); ) {
if (FD_ISSET(c->first, &rfds)) {
// Read it
- P2PVR::Data buf(1 << 16);
+ Data buf(1 << 16);
int nr = read(c->first, &buf.front(), buf.size());
if (nr < 0) {
logger->messagebf(LOG::DEBUG, "%s: read failed (%d:%s)", __PRETTY_FUNCTION__, errno, strerror(errno));
@@ -377,7 +379,7 @@ Tuner::GetLastUsedTime(const Ice::Current &)
return lastUsedTime;
}
-Tuner::IDataSender::IDataSender(const P2PVR::RawDataClientPrx & c) :
+Tuner::IDataSender::IDataSender(const RawDataClientPrx & c) :
_packetsSent(0),
client(c)
{
@@ -412,4 +414,6 @@ ICETRAY_OPTIONS(Tuner::Options,
("p2pvr.tuner.demuxstreambuffersize", po::value(&DemuxStreamBufferSize)->default_value(1024*1024),
"Kernel buffer size for demux stream data (bytes, default 1MB)")
)
+}
+}
diff --git a/p2pvr/devices/tuner.h b/p2pvr/devices/tuner.h
index 42f2948..e170002 100644
--- a/p2pvr/devices/tuner.h
+++ b/p2pvr/devices/tuner.h
@@ -13,20 +13,26 @@
#include <options.h>
#include <logger.h>
-class Tuner : public P2PVR::PrivateTuner {
+namespace P2PVR {
+namespace DVB {
+namespace Frontends {
+ class OFDM;
+}
+
+class Tuner : public PrivateTuner {
public:
class IDataSender {
public:
- IDataSender(const P2PVR::RawDataClientPrx &);
+ IDataSender(const RawDataClientPrx &);
virtual ~IDataSender() = 0;
- virtual void NewData(const P2PVR::Data &) = 0;
+ virtual void NewData(const Data &) = 0;
virtual bool IsFinished() = 0;
uint64_t PacketsSent() const;
protected:
uint64_t _packetsSent;
- const P2PVR::RawDataClientPrx client;
+ const RawDataClientPrx client;
};
typedef boost::shared_ptr<IDataSender> BackgroundClient;
typedef std::map<int, BackgroundClient> BackgroundClients;
@@ -38,25 +44,25 @@ class Tuner : public P2PVR::PrivateTuner {
int GetStatus(const Ice::Current&);
std::string Device() const;
- void ScanAndSendNetworkInformation(const P2PVR::RawDataClientPrx & client, const Ice::Current&);
- void SendNetworkInformation(const P2PVR::RawDataClientPrx & client, const Ice::Current&);
- void SendBouquetAssociations(const P2PVR::RawDataClientPrx & client, const Ice::Current&);
- void SendServiceDescriptions(const P2PVR::RawDataClientPrx & client, const Ice::Current&);
- void SendProgramMap(Ice::Int pid, const P2PVR::RawDataClientPrx & client, const Ice::Current&);
- void SendProgramAssociationTable(const P2PVR::RawDataClientPrx & client, const Ice::Current&);
- void SendEventInformation(const P2PVR::RawDataClientPrx & client, const Ice::Current&);
+ void ScanAndSendNetworkInformation(const RawDataClientPrx & client, const Ice::Current&);
+ void SendNetworkInformation(const RawDataClientPrx & client, const Ice::Current&);
+ void SendBouquetAssociations(const RawDataClientPrx & client, const Ice::Current&);
+ void SendServiceDescriptions(const RawDataClientPrx & client, const Ice::Current&);
+ void SendProgramMap(Ice::Int pid, const RawDataClientPrx & client, const Ice::Current&);
+ void SendProgramAssociationTable(const RawDataClientPrx & client, const Ice::Current&);
+ void SendEventInformation(const RawDataClientPrx & client, const Ice::Current&);
- int StartSendingTS(const P2PVR::PacketIds & pids, const P2PVR::RawDataClientPrx & client, const Ice::Current &);
- int StartSendingSection(Ice::Int pid, const P2PVR::RawDataClientPrx & client, const Ice::Current &);
+ int StartSendingTS(const PacketIds & pids, const RawDataClientPrx & client, const Ice::Current &);
+ int StartSendingSection(Ice::Int pid, const RawDataClientPrx & client, const Ice::Current &);
void StopSending(int handle, const Ice::Current &);
Ice::Long GetLastUsedTime(const Ice::Current&);
private:
int OpenDemux() const;
- uint64_t SendPID(int pid, const P2PVR::RawDataClientPrx & client, const Ice::Current &) const;
+ uint64_t SendPID(int pid, const RawDataClientPrx & client, const Ice::Current &) const;
void RequestPID(int pid, int fd) const;
- uint64_t ReadDemuxAndSend(int fd, const P2PVR::RawDataClientPrx & client) const;
+ uint64_t ReadDemuxAndSend(int fd, const RawDataClientPrx & client) const;
void startSenderThread();
void senderThread();
static void setBufferSize(int fd, unsigned long bytes);
@@ -86,9 +92,11 @@ class Tuner : public P2PVR::PrivateTuner {
};
private:
- friend class Frontend_OFDM;
+ friend class Frontends::OFDM;
IceTray::OptionsResolver<Options> options;
};
+}
+}
#endif
diff --git a/p2pvr/devices/tunerSendSi.cpp b/p2pvr/devices/tunerSendSi.cpp
index c8a8310..0215e47 100644
--- a/p2pvr/devices/tunerSendSi.cpp
+++ b/p2pvr/devices/tunerSendSi.cpp
@@ -3,9 +3,11 @@
#include <boost/crc.hpp>
#include "siParsers/table.h"
+namespace P2PVR {
+namespace DVB {
IceTray::Logging::LoggerPtr SendSi::logger(LOGMANAGER()->getLogger<SendSi>());
-SendSi::SendSi(const P2PVR::RawDataClientPrx & c) :
+SendSi::SendSi(const RawDataClientPrx & c) :
Tuner::IDataSender(c->ice_collocationOptimized(false))
{
}
@@ -15,7 +17,7 @@ SendSi::~SendSi()
}
void
-SendSi::NewData(const P2PVR::Data & buf)
+SendSi::NewData(const Data & buf)
{
if (!IsValidSection(buf)) {
return;
@@ -48,15 +50,15 @@ SendSi::IsFinished()
}
bool
-SendSi::IsValidSection(const P2PVR::Data & buf)
+SendSi::IsValidSection(const Data & buf)
{
auto n = buf.size();
- if (n < sizeof(SiTableHeader)) {
+ if (n < sizeof(DVBSI::SiTableHeader)) {
logger->messagebf(LOG::WARNING, "Received data too small to be an SI table.");
return false;
}
- auto * tab = (const SiTableHeader *)(&buf.front());
- size_t l = sizeof(SiTableHeaderBase) + HILO(tab->section_length);
+ auto * tab = (const DVBSI::SiTableHeader *)(&buf.front());
+ size_t l = sizeof(DVBSI::SiTableHeaderBase) + HILO(tab->section_length);
if (n < l) {
logger->messagebf(LOG::WARNING, "Received data shorter than its defined length.");
return false;
@@ -73,10 +75,12 @@ SendSi::IsValidSection(const P2PVR::Data & buf)
}
bool
-SendSi::crc32(const P2PVR::Data & buf)
+SendSi::crc32(const Data & buf)
{
boost::crc_optimal<32, 0x0, 0xFFFFFFFF, 0x0, true, false> crc;
crc.process_bytes(&buf.front(), buf.size());
return crc.checksum() == 0;
}
+}
+}
diff --git a/p2pvr/devices/tunerSendSi.h b/p2pvr/devices/tunerSendSi.h
index 27d15af..8b146ff 100644
--- a/p2pvr/devices/tunerSendSi.h
+++ b/p2pvr/devices/tunerSendSi.h
@@ -4,6 +4,8 @@
#include "tuner.h"
#include <logger.h>
+namespace P2PVR {
+namespace DVB {
class SendSi : public Tuner::IDataSender {
public:
SendSi(const P2PVR::RawDataClientPrx &);
@@ -20,6 +22,8 @@ class SendSi : public Tuner::IDataSender {
bool finish;
static IceTray::Logging::LoggerPtr logger;
};
+}
+}
#endif
diff --git a/p2pvr/devices/tunerSendTs.cpp b/p2pvr/devices/tunerSendTs.cpp
index 6d4e3e1..8005311 100644
--- a/p2pvr/devices/tunerSendTs.cpp
+++ b/p2pvr/devices/tunerSendTs.cpp
@@ -1,6 +1,8 @@
#include "tunerSendTs.h"
#include <logger.h>
+namespace P2PVR {
+namespace DVB {
// ~64kb of TS packets
#define TARGET_BUFFER_SIZE (350 * 188)
// About the ICE message size limit
@@ -8,7 +10,7 @@
IceTray::Logging::LoggerPtr SendTs::logger(LOGMANAGER()->getLogger<SendTs>());
-SendTs::SendTs(const P2PVR::RawDataClientPrx & c) :
+SendTs::SendTs(const RawDataClientPrx & c) :
Tuner::IDataSender(c->ice_collocationOptimized(false))
{
buffer.reserve(TARGET_BUFFER_SIZE);
@@ -30,7 +32,7 @@ SendTs::~SendTs()
}
void
-SendTs::NewData(const P2PVR::Data & buf)
+SendTs::NewData(const Data & buf)
{
buffer.insert(buffer.end(), buf.begin(), buf.end());
if (!async && buffer.size() >= TARGET_BUFFER_SIZE) {
@@ -43,7 +45,7 @@ SendTs::sendBufferChunk()
{
if (buffer.size() > TARGET_BUFFER_LIMIT) {
auto breakPoint = buffer.begin() + TARGET_BUFFER_LIMIT;
- async = client->begin_NewData(P2PVR::Data(buffer.begin(), breakPoint));
+ async = client->begin_NewData(Data(buffer.begin(), breakPoint));
buffer.erase(buffer.begin(), breakPoint);
}
else {
@@ -74,5 +76,6 @@ SendTs::IsFinished()
return true;
}
}
-
+}
+}
diff --git a/p2pvr/devices/tunerSendTs.h b/p2pvr/devices/tunerSendTs.h
index 162248d..cd74198 100644
--- a/p2pvr/devices/tunerSendTs.h
+++ b/p2pvr/devices/tunerSendTs.h
@@ -4,6 +4,8 @@
#include "tuner.h"
#include <logger.h>
+namespace P2PVR {
+namespace DVB {
class SendTs : public Tuner::IDataSender {
public:
SendTs(const P2PVR::RawDataClientPrx &);
@@ -19,6 +21,8 @@ class SendTs : public Tuner::IDataSender {
P2PVR::Data buffer;
static IceTray::Logging::LoggerPtr logger;
};
+}
+}
#endif
diff --git a/p2pvr/dvb/bindDataHandler.cpp b/p2pvr/dvb/bindDataHandler.cpp
index cb4fd69..7b25b91 100644
--- a/p2pvr/dvb/bindDataHandler.cpp
+++ b/p2pvr/dvb/bindDataHandler.cpp
@@ -1,12 +1,16 @@
#include "bindDataHandler.h"
+namespace P2PVR {
+namespace DVBSI {
BindDataHandler::BindDataHandler(const Callback & cb) :
callBack(cb)
{
}
-bool BindDataHandler::NewData(const P2PVR::Data & data, const Ice::Current &)
+bool BindDataHandler::NewData(const Data & data, const Ice::Current &)
{
return callBack(data);
}
+}
+}
diff --git a/p2pvr/dvb/bindDataHandler.h b/p2pvr/dvb/bindDataHandler.h
index bf2034a..acbe6df 100644
--- a/p2pvr/dvb/bindDataHandler.h
+++ b/p2pvr/dvb/bindDataHandler.h
@@ -5,16 +5,20 @@
#include <visibility.h>
#include <dvb.h>
-class DLL_PUBLIC BindDataHandler : public P2PVR::RawDataClient {
+namespace P2PVR {
+namespace DVBSI {
+class DLL_PUBLIC BindDataHandler : public RawDataClient {
public:
- typedef boost::function<bool(const P2PVR::Data &)> Callback;
+ typedef boost::function<bool(const Data &)> Callback;
BindDataHandler(const Callback & cb);
- bool NewData(const P2PVR::Data & data, const Ice::Current &) override;
+ bool NewData(const Data & data, const Ice::Current &) override;
private:
const Callback callBack;
};
+}
+}
#endif
diff --git a/p2pvr/dvb/bindSiParserHandler.h b/p2pvr/dvb/bindSiParserHandler.h
index a4813c2..d5fadf7 100644
--- a/p2pvr/dvb/bindSiParserHandler.h
+++ b/p2pvr/dvb/bindSiParserHandler.h
@@ -3,6 +3,8 @@
#include <boost/function.hpp>
+namespace P2PVR {
+namespace DVBSI {
template <typename SIObject, typename Base>
class BindSiParserHandler : public Base {
public:
@@ -20,6 +22,8 @@ class BindSiParserHandler : public Base {
private:
const Callback callBack;
};
+}
+}
#endif
diff --git a/p2pvr/dvb/siParsers/event.cpp b/p2pvr/dvb/siParsers/event.cpp
index bea4747..6e290c0 100644
--- a/p2pvr/dvb/siParsers/event.cpp
+++ b/p2pvr/dvb/siParsers/event.cpp
@@ -10,6 +10,8 @@
#include <boost/tuple/tuple_comparison.hpp>
#include "event.h"
+namespace P2PVR {
+namespace DVBSI {
struct ShortEvent {
char lang_code[3];
uint8_t event_name_length;
@@ -73,7 +75,7 @@ static Glib::RefPtr<Glib::Regex> yearRegex = Glib::Regex::create("[[(]([0-9]{4})
static Glib::RefPtr<Glib::Regex> flagsRegex = Glib::Regex::create("[ []+([A-Z,]+)\\]");
void
-SiEpgParser::parseDescriptor_ShortEvent(DVBSI::EventPtr current, const u_char * data)
+SiEpgParser::parseDescriptor_ShortEvent(::DVBSI::EventPtr current, const u_char * data)
{
auto * evtdesc = reinterpret_cast<const struct ShortEvent *>(data);
StrPtr title, subtitle, desc;
@@ -168,7 +170,7 @@ SiEpgParser::parseDescriptor_ShortEvent(DVBSI::EventPtr current, const u_char *
}
void
-SiEpgParser::parseDescriptor_Component(DVBSI::EventPtr current, const u_char * data)
+SiEpgParser::parseDescriptor_Component(::DVBSI::EventPtr current, const u_char * data)
{
auto * dc = reinterpret_cast<const struct Component *>(data);
@@ -189,7 +191,7 @@ SiEpgParser::parseDescriptor_Component(DVBSI::EventPtr current, const u_char * d
}
void
-SiEpgParser::parseDescriptor_Content(DVBSI::EventPtr current, const u_char * data)
+SiEpgParser::parseDescriptor_Content(::DVBSI::EventPtr current, const u_char * data)
{
auto nc = reinterpret_cast<const Content *>(data);
current->Category = nc->content_nibble_level_1;
@@ -198,7 +200,7 @@ SiEpgParser::parseDescriptor_Content(DVBSI::EventPtr current, const u_char * dat
}
void
-SiEpgParser::parseDescriptor_ParentalRating(DVBSI::EventPtr current, const u_char * data)
+SiEpgParser::parseDescriptor_ParentalRating(::DVBSI::EventPtr current, const u_char * data)
{
auto * pr = reinterpret_cast<const ParentalRating *>(data);
switch (pr->rating) {
@@ -219,7 +221,7 @@ SiEpgParser::CheckTableId(u_char tableId) const
}
bool
-SiEpgParser::HandleTable(DVBSI::EitInformationPtr)
+SiEpgParser::HandleTable(::DVBSI::EitInformationPtr)
{
return false;
}
@@ -236,13 +238,13 @@ operator<<(Common::DateTime & dt, const boost::posix_time::ptime & pt)
}
void
-SiEpgParser::ParseSiTable(const EventInformation * eit, DVBSI::EitInformationPtr ei)
+SiEpgParser::ParseSiTable(const EventInformation * eit, ::DVBSI::EitInformationPtr ei)
{
ei->ServiceId = ntohs(eit->header.content_id);
ei->TransportStreamId = ntohs(eit->TransportStreamId);
ei->OriginalNetworkId = ntohs(eit->OriginalNetworkId);
LoopOver<EventDescriptor>(eit->data, HILO(eit->header.section_length) - 15, [this,ei](const EventDescriptor * ed) {
- DVBSI::EventPtr e = new DVBSI::Event();
+ ::DVBSI::EventPtr e = new ::DVBSI::Event();
e->EventId = ntohs(ed->EventId);
e->ServiceId = ei->ServiceId;
// <ew>
@@ -261,4 +263,6 @@ SiEpgParser::ParseSiTable(const EventInformation * eit, DVBSI::EitInformationPtr
HandleTable(e);
});
}
+}
+}
diff --git a/p2pvr/dvb/siParsers/event.h b/p2pvr/dvb/siParsers/event.h
index 5baadd4..5c331be 100644
--- a/p2pvr/dvb/siParsers/event.h
+++ b/p2pvr/dvb/siParsers/event.h
@@ -5,6 +5,8 @@
#include <dvbsi.h>
#include <visibility.h>
+namespace P2PVR {
+namespace DVBSI {
struct EventInformation {
SiTableHeader header;
uint16_t TransportStreamId;
@@ -14,23 +16,25 @@ struct EventInformation {
u_char data[];
} __attribute__((packed));
-class DLL_PUBLIC SiEpgParser : public SiTableParser<EventInformation, DVBSI::EitInformationPtr, int> {
+class DLL_PUBLIC SiEpgParser : public SiTableParser<EventInformation, ::DVBSI::EitInformationPtr, int> {
protected:
bool CheckTableId(u_char tableId) const;
int SectionNumberShift() const { return 3; }
uint8_t FirstTableId(const EventInformation * ei) { return (ei->header.tableid >= 0x60 ? 0x60 : 0x50); }
uint8_t LastTableId(const EventInformation * ei) { return ei->LastTableId; }
- void ParseSiTable(const EventInformation * eit, DVBSI::EitInformationPtr);
- bool HandleTable(DVBSI::EitInformationPtr);
- virtual bool HandleTable(DVBSI::EventPtr) = 0;
+ void ParseSiTable(const EventInformation * eit, ::DVBSI::EitInformationPtr);
+ bool HandleTable(::DVBSI::EitInformationPtr);
+ virtual bool HandleTable(::DVBSI::EventPtr) = 0;
private:
- DLL_PRIVATE static void parseStartTimeAndDuration(DVBSI::EventPtr, const u_char * data);
- DLL_PRIVATE static void parseDescriptor_ShortEvent(DVBSI::EventPtr, const u_char * data);
- DLL_PRIVATE static void parseDescriptor_Component(DVBSI::EventPtr, const u_char * data);
- DLL_PRIVATE static void parseDescriptor_Content(DVBSI::EventPtr, const u_char * data);
- DLL_PRIVATE static void parseDescriptor_ParentalRating(DVBSI::EventPtr, const u_char * data);
+ DLL_PRIVATE static void parseStartTimeAndDuration(::DVBSI::EventPtr, const u_char * data);
+ DLL_PRIVATE static void parseDescriptor_ShortEvent(::DVBSI::EventPtr, const u_char * data);
+ DLL_PRIVATE static void parseDescriptor_Component(::DVBSI::EventPtr, const u_char * data);
+ DLL_PRIVATE static void parseDescriptor_Content(::DVBSI::EventPtr, const u_char * data);
+ DLL_PRIVATE static void parseDescriptor_ParentalRating(::DVBSI::EventPtr, const u_char * data);
};
+}
+}
#endif
diff --git a/p2pvr/dvb/siParsers/network.cpp b/p2pvr/dvb/siParsers/network.cpp
index b00ddeb..cca7e9f 100644
--- a/p2pvr/dvb/siParsers/network.cpp
+++ b/p2pvr/dvb/siParsers/network.cpp
@@ -4,6 +4,19 @@
#include <safeMapFind.h>
#include <compileTimeFormatter.h>
+namespace AdHoc {
+ StreamWriterT('x') {
+ template<typename ... Pn>
+ static void write(stream & s, const int & p, const Pn & ... pn)
+ {
+ s << std::hex << p;
+ StreamWriter::next(s, pn...);
+ }
+ };
+}
+
+namespace P2PVR {
+namespace DVBSI {
struct NetworkStreamsHeader {
#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
u_char reserved1 :4;
@@ -131,13 +144,13 @@ SiNetworkInformationParser::CheckTableId(u_char tableId) const
}
void
-SiNetworkInformationParser::ParseSiTable(const struct NetworkInformation * nit, DVBSI::NetworkPtr n)
+SiNetworkInformationParser::ParseSiTable(const struct NetworkInformation * nit, ::DVBSI::NetworkPtr n)
{
n->NetworkId = ntohs(nit->header.content_id);
auto nsh = ParseDescriptors<NetworkStreamsHeader>(nit->data, HILO(nit->network_descriptor_length),
0x40, boost::bind(&SiNetworkInformationParser::parseDescriptor_NetworkName, n, _1, _2));
LoopOver<TransportStream>(nsh->data, HILO(nsh->transport_stream_loop_length), [this,n](const TransportStream * ts) {
- DVBSI::NetworkTransportStreamPtr nts = new DVBSI::NetworkTransportStream();
+ ::DVBSI::NetworkTransportStreamPtr nts = new ::DVBSI::NetworkTransportStream();
nts->TransportStreamId = ntohs(ts->transportStreamId);
nts->NetworkId = n->NetworkId;
nts->OriginalNetworkId = ntohs(ts->originalNetworkId);
@@ -151,22 +164,11 @@ SiNetworkInformationParser::ParseSiTable(const struct NetworkInformation * nit,
}
void
-SiNetworkInformationParser::parseDescriptor_NetworkName(DVBSI::NetworkPtr n, const u_char * p, size_t len)
+SiNetworkInformationParser::parseDescriptor_NetworkName(::DVBSI::NetworkPtr n, const u_char * p, size_t len)
{
n->Name = *convert((const char *)p, len);
}
-namespace AdHoc {
- StreamWriterT('x') {
- template<typename ... Pn>
- static void write(stream & s, const int & p, const Pn & ... pn)
- {
- s << std::hex << p;
- StreamWriter::next(s, pn...);
- }
- };
-}
-
AdHocFormatter(WhatIsntSupported, "%? %x");
class NotSupported : public std::runtime_error {
public:
@@ -230,11 +232,11 @@ std::map<short, fe_transmit_mode_t> ttransmitmodes {
SINOTSUPPORTED(TransmissionMode);
void
-SiNetworkInformationParser::parseDescriptor_TerrestrialDelivery(DVBSI::NetworkTransportStreamPtr nts, const u_char * data, size_t len)
+SiNetworkInformationParser::parseDescriptor_TerrestrialDelivery(::DVBSI::NetworkTransportStreamPtr nts, const u_char * data, size_t len)
{
assert(len == sizeof(TerrestrialDeliveryDescriptor));
auto tdd = reinterpret_cast<const TerrestrialDeliveryDescriptor *>(data);
- DVBSI::TerrestrialDeliveryPtr td = new DVBSI::TerrestrialDelivery;
+ ::DVBSI::TerrestrialDeliveryPtr td = new ::DVBSI::TerrestrialDelivery;
td->Frequency = ((uint64_t)ntohl(tdd->Frequency)) * 10;
td->TransportStreamId = nts->TransportStreamId;
td->Bandwidth = AdHoc::safeMapLookup<BandwidthNotSupported>(tbandwidths, tdd->Bandwidth);
@@ -252,11 +254,11 @@ SiNetworkInformationParser::parseDescriptor_TerrestrialDelivery(DVBSI::NetworkTr
}
void
-SiNetworkInformationParser::parseDescriptor_CableDelivery(DVBSI::NetworkTransportStreamPtr nts, const u_char * data, size_t len)
+SiNetworkInformationParser::parseDescriptor_CableDelivery(::DVBSI::NetworkTransportStreamPtr nts, const u_char * data, size_t len)
{
assert(len == sizeof(CableDeliveryDescriptor));
auto cdd = reinterpret_cast<const CableDeliveryDescriptor *>(data);
- DVBSI::CableDeliveryPtr cd = new DVBSI::CableDelivery;
+ ::DVBSI::CableDeliveryPtr cd = new ::DVBSI::CableDelivery;
cd->Frequency = ((uint64_t)ntohl(cdd->Frequency)) * 10;
cd->TransportStreamId = nts->TransportStreamId;
cd->FecOuter = cdd->FecOuter;
@@ -267,11 +269,11 @@ SiNetworkInformationParser::parseDescriptor_CableDelivery(DVBSI::NetworkTranspor
}
void
-SiNetworkInformationParser::parseDescriptor_SatelliteDelivery(DVBSI::NetworkTransportStreamPtr nts, const u_char * data, size_t len)
+SiNetworkInformationParser::parseDescriptor_SatelliteDelivery(::DVBSI::NetworkTransportStreamPtr nts, const u_char * data, size_t len)
{
assert(len == sizeof(SatelliteDeliveryDescriptor));
auto sdd = reinterpret_cast<const SatelliteDeliveryDescriptor *>(data);
- DVBSI::SatelliteDeliveryPtr sd = new DVBSI::SatelliteDelivery;
+ ::DVBSI::SatelliteDeliveryPtr sd = new ::DVBSI::SatelliteDelivery;
sd->Frequency = ((uint64_t)ntohl(sdd->Frequency)) * 10;
sd->TransportStreamId = nts->TransportStreamId;
sd->OrbitalPosition = ntohs(sdd->OrbitalPosition);
@@ -286,7 +288,7 @@ SiNetworkInformationParser::parseDescriptor_SatelliteDelivery(DVBSI::NetworkTran
}
void
-SiNetworkInformationParser::parseDescriptor_ServiceList(DVBSI::NetworkTransportStreamPtr nts, const u_char * data, size_t len)
+SiNetworkInformationParser::parseDescriptor_ServiceList(::DVBSI::NetworkTransportStreamPtr nts, const u_char * data, size_t len)
{
auto end = data + len;
while (data < end) {
@@ -295,5 +297,6 @@ SiNetworkInformationParser::parseDescriptor_ServiceList(DVBSI::NetworkTransportS
data += sizeof(ServiceListDescriptor);
}
}
-
+}
+}
diff --git a/p2pvr/dvb/siParsers/network.h b/p2pvr/dvb/siParsers/network.h
index fef11d0..fa2db82 100644
--- a/p2pvr/dvb/siParsers/network.h
+++ b/p2pvr/dvb/siParsers/network.h
@@ -5,6 +5,8 @@
#include <dvbsi.h>
#include <visibility.h>
+namespace P2PVR {
+namespace DVBSI {
struct NetworkInformation {
SiTableHeader header;
#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
@@ -18,18 +20,20 @@ struct NetworkInformation {
u_char data[];
} __attribute__((packed));
-class DLL_PUBLIC SiNetworkInformationParser : public SiTableParser<NetworkInformation, DVBSI::NetworkPtr, u_char> {
+class DLL_PUBLIC SiNetworkInformationParser : public SiTableParser<NetworkInformation, ::DVBSI::NetworkPtr, u_char> {
protected:
bool CheckTableId(u_char tableId) const;
- void ParseSiTable(const struct NetworkInformation * nit, DVBSI::NetworkPtr);
+ void ParseSiTable(const struct NetworkInformation * nit, ::DVBSI::NetworkPtr);
private:
- DLL_PRIVATE static void parseDescriptor_NetworkName(DVBSI::NetworkPtr, const u_char *data, size_t len);
- DLL_PRIVATE static void parseDescriptor_ServiceList(DVBSI::NetworkTransportStreamPtr, const u_char *data, size_t len);
- DLL_PRIVATE static void parseDescriptor_TerrestrialDelivery(DVBSI::NetworkTransportStreamPtr, const u_char *data, size_t len);
- DLL_PRIVATE static void parseDescriptor_SatelliteDelivery(DVBSI::NetworkTransportStreamPtr, const u_char *data, size_t len);
- DLL_PRIVATE static void parseDescriptor_CableDelivery(DVBSI::NetworkTransportStreamPtr, const u_char *data, size_t len);
+ DLL_PRIVATE static void parseDescriptor_NetworkName(::DVBSI::NetworkPtr, const u_char *data, size_t len);
+ DLL_PRIVATE static void parseDescriptor_ServiceList(::DVBSI::NetworkTransportStreamPtr, const u_char *data, size_t len);
+ DLL_PRIVATE static void parseDescriptor_TerrestrialDelivery(::DVBSI::NetworkTransportStreamPtr, const u_char *data, size_t len);
+ DLL_PRIVATE static void parseDescriptor_SatelliteDelivery(::DVBSI::NetworkTransportStreamPtr, const u_char *data, size_t len);
+ DLL_PRIVATE static void parseDescriptor_CableDelivery(::DVBSI::NetworkTransportStreamPtr, const u_char *data, size_t len);
};
+}
+}
#endif
diff --git a/p2pvr/dvb/siParsers/programAssociation.cpp b/p2pvr/dvb/siParsers/programAssociation.cpp
index 0add29e..c3faf3a 100644
--- a/p2pvr/dvb/siParsers/programAssociation.cpp
+++ b/p2pvr/dvb/siParsers/programAssociation.cpp
@@ -1,5 +1,7 @@
#include "programAssociation.h"
+namespace P2PVR {
+namespace DVBSI {
struct ProgramAssociation {
uint16_t program_number;
#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
@@ -25,5 +27,6 @@ SiProgramAssociationParser::ParseSiTable(const ProgramAssociationSection * pas,
(*pam)[ntohs(sd->program_number)] = HILO(sd->pid);
});
}
-
+}
+}
diff --git a/p2pvr/dvb/siParsers/programAssociation.h b/p2pvr/dvb/siParsers/programAssociation.h
index 3ef44f0..8588e3d 100644
--- a/p2pvr/dvb/siParsers/programAssociation.h
+++ b/p2pvr/dvb/siParsers/programAssociation.h
@@ -5,6 +5,8 @@
#include <dvbsi.h>
#include <visibility.h>
+namespace P2PVR {
+namespace DVBSI {
struct ProgramAssociationSection {
SiTableHeader header;
u_char data[];
@@ -18,6 +20,8 @@ class DLL_PUBLIC SiProgramAssociationParser : public SiTableParser<ProgramAssoci
bool CheckTableId(u_char tableId) const;
void ParseSiTable(const struct ProgramAssociationSection * pas, ProgramAssociationMapPtr);
};
+}
+}
#endif
diff --git a/p2pvr/dvb/siParsers/programMap.cpp b/p2pvr/dvb/siParsers/programMap.cpp
index 448bda0..90bb8cf 100644
--- a/p2pvr/dvb/siParsers/programMap.cpp
+++ b/p2pvr/dvb/siParsers/programMap.cpp
@@ -1,6 +1,8 @@
#include "programMap.h"
#include <boost/bind.hpp>
+namespace P2PVR {
+namespace DVBSI {
struct ProgramMapStream {
uint8_t stream_type;
#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
@@ -30,12 +32,12 @@ SiProgramMapParser::CheckTableId(u_char tableId) const
}
void
-SiProgramMapParser::ParseSiTable(const struct ProgramMap * pm, DVBSI::ProgramMapPtr pmp)
+SiProgramMapParser::ParseSiTable(const struct ProgramMap * pm, ::DVBSI::ProgramMapPtr pmp)
{
pmp->ServiceId = ntohs(pm->header.content_id);
auto pms = ParseDescriptors<ProgramMapStream>(pm->data, HILO(pm->program_info_len));
while (reinterpret_cast<const u_char*>(pms) < &pm->header.section_length_lo + HILO(pm->header.section_length) - 4) {
- DVBSI::StreamPtr s = new DVBSI::Stream();
+ ::DVBSI::StreamPtr s = new ::DVBSI::Stream();
s->Type = pms->stream_type;
s->Id = HILO(pms->elementary_PID);
s->ServiceId = pmp->ServiceId;
@@ -44,3 +46,6 @@ SiProgramMapParser::ParseSiTable(const struct ProgramMap * pm, DVBSI::ProgramMap
pms = ParseDescriptors<ProgramMapStream>(pms->data, HILO(pms->ES_info_length));
}
}
+}
+}
+
diff --git a/p2pvr/dvb/siParsers/programMap.h b/p2pvr/dvb/siParsers/programMap.h
index 14f0c8d..89f8633 100644
--- a/p2pvr/dvb/siParsers/programMap.h
+++ b/p2pvr/dvb/siParsers/programMap.h
@@ -5,6 +5,8 @@
#include <dvbsi.h>
#include <visibility.h>
+namespace P2PVR {
+namespace DVBSI {
struct ProgramMap {
SiTableHeader header;
#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
@@ -26,13 +28,13 @@ struct ProgramMap {
u_char data[];
} __attribute__((packed));
-class DLL_PUBLIC SiProgramMapParser : public SiTableParser<ProgramMap, DVBSI::ProgramMapPtr, u_char> {
+class DLL_PUBLIC SiProgramMapParser : public SiTableParser<ProgramMap, ::DVBSI::ProgramMapPtr, u_char> {
protected:
bool CheckTableId(u_char tableId) const;
- void ParseSiTable(const struct ProgramMap * nit, DVBSI::ProgramMapPtr);
+ void ParseSiTable(const struct ProgramMap * nit, ::DVBSI::ProgramMapPtr);
};
+}
+}
#endif
-
-
diff --git a/p2pvr/dvb/siParsers/service.cpp b/p2pvr/dvb/siParsers/service.cpp
index 56452e9..6f4e27b 100644
--- a/p2pvr/dvb/siParsers/service.cpp
+++ b/p2pvr/dvb/siParsers/service.cpp
@@ -1,6 +1,8 @@
#include "service.h"
#include <boost/bind.hpp>
+namespace P2PVR {
+namespace DVBSI {
struct ServiceDescriptor {
uint16_t ServiceId;
#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
@@ -32,12 +34,12 @@ SiServicesParser::CheckTableId(u_char tableId) const
}
void
-SiServicesParser::ParseSiTable(const TransportStreamDescriptor * tsd, DVBSI::TransportStreamPtr ts)
+SiServicesParser::ParseSiTable(const TransportStreamDescriptor * tsd, ::DVBSI::TransportStreamPtr ts)
{
ts->TransportStreamId = ntohs(tsd->header.content_id);
ts->OriginalNetworkId = ntohs(tsd->original_network_id);
LoopOver<ServiceDescriptor>(tsd->data, HILO(tsd->header.section_length) - 12, [this,ts](const ServiceDescriptor * sd) {
- DVBSI::ServicePtr s = new DVBSI::Service();
+ ::DVBSI::ServicePtr s = new ::DVBSI::Service();
s->ServiceId = ntohs(sd->ServiceId);
s->TransportStreamId = ts->TransportStreamId;
s->EitSchedule = sd->EitSchedule;
@@ -52,7 +54,7 @@ SiServicesParser::ParseSiTable(const TransportStreamDescriptor * tsd, DVBSI::Tra
}
void
-SiServicesParser::parseDescriptor_Service(DVBSI::ServicePtr s, const u_char * p, size_t)
+SiServicesParser::parseDescriptor_Service(::DVBSI::ServicePtr s, const u_char * p, size_t)
{
s->Type = p[0];
if (p[1]) {
@@ -62,8 +64,10 @@ SiServicesParser::parseDescriptor_Service(DVBSI::ServicePtr s, const u_char * p,
}
void
-SiServicesParser::parseDescriptor_DefaultAuthority(DVBSI::ServicePtr s, const u_char * p, size_t len)
+SiServicesParser::parseDescriptor_DefaultAuthority(::DVBSI::ServicePtr s, const u_char * p, size_t len)
{
s->DefaultAuthority = *convert((const char *)p, len);
}
+}
+}
diff --git a/p2pvr/dvb/siParsers/service.h b/p2pvr/dvb/siParsers/service.h
index 64ec351..39dd9d7 100644
--- a/p2pvr/dvb/siParsers/service.h
+++ b/p2pvr/dvb/siParsers/service.h
@@ -5,6 +5,8 @@
#include <dvbsi.h>
#include <visibility.h>
+namespace P2PVR {
+namespace DVBSI {
struct TransportStreamDescriptor {
SiTableHeader header;
uint16_t original_network_id;
@@ -12,15 +14,17 @@ struct TransportStreamDescriptor {
u_char data[];
} __attribute__((packed));
-class DLL_PUBLIC SiServicesParser : public SiTableParser<TransportStreamDescriptor, DVBSI::TransportStreamPtr, int> {
+class DLL_PUBLIC SiServicesParser : public SiTableParser<TransportStreamDescriptor, ::DVBSI::TransportStreamPtr, int> {
protected:
bool CheckTableId(u_char tableId) const;
- void ParseSiTable(const struct TransportStreamDescriptor * nit, DVBSI::TransportStreamPtr);
+ void ParseSiTable(const struct TransportStreamDescriptor * nit, ::DVBSI::TransportStreamPtr);
private:
- DLL_PRIVATE static void parseDescriptor_Service(DVBSI::ServicePtr, const u_char *data, size_t len);
- DLL_PRIVATE static void parseDescriptor_DefaultAuthority(DVBSI::ServicePtr, const u_char *data, size_t len);
+ DLL_PRIVATE static void parseDescriptor_Service(::DVBSI::ServicePtr, const u_char *data, size_t len);
+ DLL_PRIVATE static void parseDescriptor_DefaultAuthority(::DVBSI::ServicePtr, const u_char *data, size_t len);
};
+}
+}
#endif
diff --git a/p2pvr/dvb/siParsers/table.cpp b/p2pvr/dvb/siParsers/table.cpp
index 455d0a4..40af5fb 100644
--- a/p2pvr/dvb/siParsers/table.cpp
+++ b/p2pvr/dvb/siParsers/table.cpp
@@ -3,6 +3,8 @@
#include <stdio.h>
#include <glibmm.h>
+namespace P2PVR {
+namespace DVBSI {
const std::string SiTableParserBase::ISO10646("ISO-10646");
const std::string SiTableParserBase::EitEncoding("ISO6937");
const std::string SiTableParserBase::UTF8("UTF8");
@@ -71,4 +73,6 @@ SiTableParserBase::convert(const char * txt, size_t len)
}
return boost::shared_ptr<Glib::ustring>(new Glib::ustring(utf8.get()));
}
+}
+}
diff --git a/p2pvr/dvb/siParsers/table.h b/p2pvr/dvb/siParsers/table.h
index effcfa2..821bf93 100644
--- a/p2pvr/dvb/siParsers/table.h
+++ b/p2pvr/dvb/siParsers/table.h
@@ -20,6 +20,8 @@ typedef unsigned char u_char;
#define HILO4(x) (x##4 << 24 | x##2 << 16 | x##3 << 8 | x##4)
#define BcdCharToInt(x) (10*((x & 0xF0)>>4) + (x & 0xF))
+namespace P2PVR {
+namespace DVBSI {
class DLL_PUBLIC SiTableParserBase : public P2PVR::RawDataClient {
public:
const P2PVR::Data & CurrentRawData() const;
@@ -210,6 +212,8 @@ class SiTableParser : public SiTableParserBase {
private:
mutable Contents contents;
};
+}
+}
#endif
diff --git a/p2pvr/dvb/unittests/createBroadcast.cpp b/p2pvr/dvb/unittests/createBroadcast.cpp
index b910744..ee147f2 100644
--- a/p2pvr/dvb/unittests/createBroadcast.cpp
+++ b/p2pvr/dvb/unittests/createBroadcast.cpp
@@ -9,12 +9,12 @@
#include <linux/dvb/frontend.h>
#include "serviceStreamerCore.h"
#include "bindDataHandler.h"
+#include <definedDirs.h>
-#define XSTR(s) STR(s)
-#define STR(s) #s
-const boost::filesystem::path root(XSTR(ROOT));
+namespace P2PVR {
+namespace Testing {
-Ice::StringSeq params {
+static Ice::StringSeq params {
"--Ice.ThreadPool.Client.Size=5",
"--Ice.ThreadPool.Client.SizeMax=10",
"--Ice.ThreadPool.Server.Size=5",
@@ -29,7 +29,7 @@ class Core {
{
adapter->activate();
- devs = P2PVR::DevicesPrx::checkedCast(ic->stringToProxy("Devices:tcp -h defiant -p 10000"));
+ devs = DevicesPrx::checkedCast(ic->stringToProxy("Devices:tcp -h defiant -p 10000"));
BOOST_REQUIRE(devs);
devs->ice_ping();
}
@@ -39,7 +39,7 @@ class Core {
ic->destroy();
}
- P2PVR::DevicesPrx devs;
+ DevicesPrx devs;
Ice::CommunicatorPtr ic;
Ice::ObjectAdapterPtr adapter;
@@ -47,29 +47,29 @@ class Core {
class Sampler {
public:
- Sampler(int sid, P2PVR::DevicesPrx d, Ice::ObjectAdapterPtr a) :
- patp(a, new BindDataHandler(boost::bind(&Sampler::Handle, this, _1, boost::ref(pat)))),
- pmtp(a, new BindDataHandler(boost::bind(&Sampler::Handle, this, _1, boost::ref(pmt)))),
- vidp(a, new BindDataHandler(boost::bind(&Sampler::Handle, this, _1, boost::ref(vid)))),
+ Sampler(int sid, DevicesPrx d, Ice::ObjectAdapterPtr a) :
+ patp(a, new DVBSI::BindDataHandler(boost::bind(&Sampler::Handle, this, _1, boost::ref(pat)))),
+ pmtp(a, new DVBSI::BindDataHandler(boost::bind(&Sampler::Handle, this, _1, boost::ref(pmt)))),
+ vidp(a, new DVBSI::BindDataHandler(boost::bind(&Sampler::Handle, this, _1, boost::ref(vid)))),
ss(sid, patp, pmtp, vidp, d, a)
{
}
- TemporaryIceAdapterObject<P2PVR::RawDataClient> patp;
- TemporaryIceAdapterObject<P2PVR::RawDataClient> pmtp;
- TemporaryIceAdapterObject<P2PVR::RawDataClient> vidp;
+ TemporaryIceAdapterObject<RawDataClient> patp;
+ TemporaryIceAdapterObject<RawDataClient> pmtp;
+ TemporaryIceAdapterObject<RawDataClient> vidp;
ServiceStreamerCore ss;
- typedef std::list<P2PVR::Data> Sampled;
+ typedef std::list<Data> Sampled;
Sampled pat, pmt, vid;
- bool Handle(const P2PVR::Data & data, Sampled & rec)
+ bool Handle(const Data & data, Sampled & rec)
{
rec.push_back(data);
return false;
}
- void Start(DVBSI::DeliveryPtr transport) { ss.Start(transport); }
+ void Start(::DVBSI::DeliveryPtr transport) { ss.Start(transport); }
void Stop() { ss.Stop(); }
void Save(Ice::CommunicatorPtr ic)
@@ -86,16 +86,18 @@ class Sampler {
out->write(s);
Ice::ByteSeq buf;
out->finished(buf);
- BOOST_TEST_MESSAGE(root);
- auto outFile = fopen((root / fileName).string().c_str(), "w");
+ BOOST_TEST_MESSAGE(rootDir);
+ auto outFile = fopen((rootDir / fileName).string().c_str(), "w");
BOOST_REQUIRE(outFile);
BOOST_REQUIRE_EQUAL(1, fwrite(&buf.front(), buf.size(), 1, outFile));
BOOST_REQUIRE_EQUAL(0, fclose(outFile));
}
};
+}
+}
-BOOST_FIXTURE_TEST_SUITE( X, Core )
+BOOST_FIXTURE_TEST_SUITE( X, P2PVR::Testing::Core )
BOOST_AUTO_TEST_CASE( broadcast_sample )
{
@@ -111,7 +113,7 @@ BOOST_AUTO_TEST_CASE( broadcast_sample )
tuner->ice_ping();
BOOST_TEST_CHECKPOINT("Create sampler");
- Sampler sampler(4170, devs, adapter);
+ P2PVR::Testing::Sampler sampler(4170, devs, adapter);
BOOST_TEST_CHECKPOINT("Start stream");
sampler.Start(transport);
diff --git a/p2pvr/dvb/unittests/createSamples.cpp b/p2pvr/dvb/unittests/createSamples.cpp
index f9909af..6c4ef5c 100644
--- a/p2pvr/dvb/unittests/createSamples.cpp
+++ b/p2pvr/dvb/unittests/createSamples.cpp
@@ -11,11 +11,10 @@
#include <siParsers/network.h>
#include <siParsers/service.h>
#include <siParsers/event.h>
+#include <definedDirs.h>
-#define XSTR(s) STR(s)
-#define STR(s) #s
-const boost::filesystem::path root(XSTR(ROOT));
-
+namespace P2PVR {
+namespace Testing {
template <class Parser>
static
boost::tuple<Ice::CommunicatorPtr, Ice::ObjectAdapterPtr, Parser *>
@@ -48,14 +47,14 @@ class SiSampleCollector : public Base {
return false;
}
- bool NewData(const P2PVR::Data & bytes, const Ice::Current & ice) override
+ bool NewData(const Data & bytes, const Ice::Current & ice) override
{
std::lock_guard<std::mutex> g(lock);
packets.push_back(bytes);
- return SiTableParserBase::NewData(bytes, ice);
+ return DVBSI::SiTableParserBase::NewData(bytes, ice);
}
- std::list<P2PVR::Data> packets;
+ std::list<Data> packets;
private:
std::mutex lock;
@@ -64,7 +63,7 @@ class SiSampleCollector : public Base {
template <class Base, class Object>
static
void
-CaptureAndSave(const boost::filesystem::path & fileName, const boost::function<void(P2PVR::TunerPrx, P2PVR::RawDataClientPrx)> & method)
+CaptureAndSave(const boost::filesystem::path & fileName, const boost::function<void(TunerPrx, RawDataClientPrx)> & method)
{
auto icp = standardConfig<SiSampleCollector<Base, Object>>();
auto ic = boost::get<0>(icp);
@@ -72,21 +71,21 @@ CaptureAndSave(const boost::filesystem::path & fileName, const boost::function<v
auto p = boost::get<2>(icp);
AdHoc::ScopeExit _([&ic]{ ic->destroy(); });
- auto devs = P2PVR::DevicesPrx::checkedCast(ic->stringToProxy("Devices:tcp -h defiant -p 10000"));
- auto parser = P2PVR::RawDataClientPrx::checkedCast(adap->createProxy(ic->stringToIdentity("parser")));
+ auto devs = DevicesPrx::checkedCast(ic->stringToProxy("Devices:tcp -h defiant -p 10000"));
+ auto parser = RawDataClientPrx::checkedCast(adap->createProxy(ic->stringToIdentity("parser")));
BOOST_REQUIRE(devs);
devs->ice_ping();
BOOST_REQUIRE(parser);
parser->ice_ping();
- DVBSI::TerrestrialDeliveryPtr transport = new DVBSI::TerrestrialDelivery {
+ ::DVBSI::TerrestrialDeliveryPtr transport = new ::DVBSI::TerrestrialDelivery {
4170, 682000000, 0, true, true, true, 3, 0, 2, 1, 0, 1, true
};
BOOST_REQUIRE_EQUAL(transport->Frequency, 682000000);
BOOST_REQUIRE_EQUAL(transport->TransmissionMode, 1);
BOOST_TEST_CHECKPOINT("Acquire device");
- P2PVR::TunerPrx tuner = devs->GetTunerAny(transport);
+ TunerPrx tuner = devs->GetTunerAny(transport);
BOOST_REQUIRE(tuner);
tuner->ice_ping();
@@ -103,28 +102,34 @@ CaptureAndSave(const boost::filesystem::path & fileName, const boost::function<v
out->write(p->packets);
Ice::ByteSeq buf;
out->finished(buf);
- BOOST_TEST_MESSAGE(root);
- auto outFile = fopen((root / fileName).string().c_str(), "w");
+ BOOST_TEST_MESSAGE(rootDir);
+ auto outFile = fopen((rootDir / fileName).string().c_str(), "w");
BOOST_REQUIRE(outFile);
BOOST_REQUIRE_EQUAL(1, fwrite(&buf.front(), buf.size(), 1, outFile));
BOOST_REQUIRE_EQUAL(0, fclose(outFile));
}
+}
+}
+
+using namespace P2PVR;
+using namespace P2PVR::Testing;
+using namespace P2PVR::DVBSI;
BOOST_AUTO_TEST_CASE( network_sample )
{
- CaptureAndSave<SiNetworkInformationParser, DVBSI::NetworkPtr>("network.dat",
- [](P2PVR::TunerPrx t, P2PVR::RawDataClientPrx rdc) { t->SendNetworkInformation(rdc); });
+ CaptureAndSave<SiNetworkInformationParser, ::DVBSI::NetworkPtr>("network.dat",
+ [](TunerPrx t, RawDataClientPrx rdc) { t->SendNetworkInformation(rdc); });
}
BOOST_AUTO_TEST_CASE( services_sample )
{
- CaptureAndSave<SiServicesParser, DVBSI::TransportStreamPtr>("services.dat",
- [](P2PVR::TunerPrx t, P2PVR::RawDataClientPrx rdc) { t->SendServiceDescriptions(rdc); });
+ CaptureAndSave<SiServicesParser, ::DVBSI::TransportStreamPtr>("services.dat",
+ [](TunerPrx t, RawDataClientPrx rdc) { t->SendServiceDescriptions(rdc); });
}
BOOST_AUTO_TEST_CASE( events_sample )
{
- CaptureAndSave<SiEpgParser, DVBSI::EventPtr>("events.dat",
- [](P2PVR::TunerPrx t, P2PVR::RawDataClientPrx rdc) { t->SendEventInformation(rdc); });
+ CaptureAndSave<SiEpgParser, ::DVBSI::EventPtr>("events.dat",
+ [](TunerPrx t, RawDataClientPrx rdc) { t->SendEventInformation(rdc); });
}
diff --git a/p2pvr/lib/bindTimerTask.cpp b/p2pvr/lib/bindTimerTask.cpp
index b3a0150..96a7854 100644
--- a/p2pvr/lib/bindTimerTask.cpp
+++ b/p2pvr/lib/bindTimerTask.cpp
@@ -1,5 +1,6 @@
#include "bindTimerTask.h"
+namespace P2PVR {
BindTimerTask::BindTimerTask(const Event & e) :
event(e)
{
@@ -10,4 +11,5 @@ BindTimerTask::runTimerTask()
{
event();
}
+}
diff --git a/p2pvr/lib/bindTimerTask.h b/p2pvr/lib/bindTimerTask.h
index f420ee0..3aff9d0 100644
--- a/p2pvr/lib/bindTimerTask.h
+++ b/p2pvr/lib/bindTimerTask.h
@@ -5,6 +5,7 @@
#include <IceUtil/Timer.h>
#include <visibility.h>
+namespace P2PVR {
class DLL_PUBLIC BindTimerTask : public IceUtil::TimerTask {
public:
typedef boost::function<void()> Event;
@@ -14,6 +15,7 @@ class DLL_PUBLIC BindTimerTask : public IceUtil::TimerTask {
private:
const Event event;
};
+}
#endif
diff --git a/p2pvr/lib/fileHandle.cpp b/p2pvr/lib/fileHandle.cpp
index 08575b3..e568f44 100644
--- a/p2pvr/lib/fileHandle.cpp
+++ b/p2pvr/lib/fileHandle.cpp
@@ -2,6 +2,7 @@
#include <unistd.h>
#include <stdexcept>
+namespace P2PVR {
class InvalidFileHandle : public std::runtime_error {
public:
InvalidFileHandle() : std::runtime_error("Invalid file handle") { }
@@ -24,4 +25,5 @@ FileHandle::operator int() const
{
return fd;
}
+}
diff --git a/p2pvr/lib/fileHandle.h b/p2pvr/lib/fileHandle.h
index 0a3b7fc..f2d6929 100644
--- a/p2pvr/lib/fileHandle.h
+++ b/p2pvr/lib/fileHandle.h
@@ -3,6 +3,7 @@
#include <visibility.h>
+namespace P2PVR {
class DLL_PUBLIC FileHandle {
public:
FileHandle(int fd);
@@ -16,6 +17,7 @@ class DLL_PUBLIC FileHandle {
private:
const int fd;
};
+}
#endif
diff --git a/p2pvr/lib/fileSink.cpp b/p2pvr/lib/fileSink.cpp
index d3fda8f..295d550 100644
--- a/p2pvr/lib/fileSink.cpp
+++ b/p2pvr/lib/fileSink.cpp
@@ -1,5 +1,6 @@
#include "fileSink.h"
+namespace P2PVR {
FileSink::FileSink(const boost::filesystem::path & path) :
file(fopen(path.string().c_str(), "w"))
{
@@ -18,9 +19,10 @@ FileSink::~FileSink()
}
bool
-FileSink::NewData(const P2PVR::Data & data, const Ice::Current &)
+FileSink::NewData(const Data & data, const Ice::Current &)
{
fwrite(&data.front(), data.size(), 1, file);
return false;
}
+}
diff --git a/p2pvr/lib/fileSink.h b/p2pvr/lib/fileSink.h
index fbd469c..840f995 100644
--- a/p2pvr/lib/fileSink.h
+++ b/p2pvr/lib/fileSink.h
@@ -6,17 +6,19 @@
#include <dvb.h>
#include <visibility.h>
-class DLL_PUBLIC FileSink : public P2PVR::RawDataClient {
+namespace P2PVR {
+class DLL_PUBLIC FileSink : public RawDataClient {
public:
FileSink(const boost::filesystem::path & path);
FileSink(int fd);
~FileSink();
- bool NewData(const P2PVR::Data & data, const Ice::Current &);
+ bool NewData(const Data & data, const Ice::Current &);
private:
FILE * const file;
};
+}
#endif
diff --git a/p2pvr/lib/muxer.cpp b/p2pvr/lib/muxer.cpp
index 1f306cd..b4a249c 100644
--- a/p2pvr/lib/muxer.cpp
+++ b/p2pvr/lib/muxer.cpp
@@ -6,11 +6,12 @@
#include <boost/algorithm/string/split.hpp>
#include <boost/algorithm/string/classification.hpp>
+namespace P2PVR {
IceTray::Logging::LoggerPtr Muxer::log(LOGMANAGER()->getLogger<Muxer>());
-class MuxerFailure : public P2PVR::DataHandlingException { };
+class MuxerFailure : public DataHandlingException { };
-Muxer::Muxer(const P2PVR::RawDataClientPrx & t, const std::string & cmd) :
+Muxer::Muxer(const RawDataClientPrx & t, const std::string & cmd) :
target(t)
{
std::vector<std::string> params;
@@ -31,7 +32,7 @@ Muxer::~Muxer()
}
bool
-Muxer::NewData(const P2PVR::Data & data, const Ice::Current &)
+Muxer::NewData(const Data & data, const Ice::Current &)
{
std::lock_guard<std::mutex> g(lock);
for (size_t off = 0; off < data.size(); ) {
@@ -96,7 +97,7 @@ Muxer::ReadMuxerAndSend(int waitTime) const
else {
bool closed = false;
if (fd[0].revents & (POLLIN | POLLHUP)) {
- P2PVR::Data buf(BUFSIZ);
+ Data buf(BUFSIZ);
auto len = read(fds->fdOut(), &buf.front(), buf.size());
if (len == 0) {
// ok, proc exit
@@ -110,7 +111,7 @@ Muxer::ReadMuxerAndSend(int waitTime) const
target->NewData(buf);
}
if (fd[1].revents & (POLLIN | POLLHUP)) {
- P2PVR::Data buf(BUFSIZ);
+ Data buf(BUFSIZ);
auto len = read(fds->fdError(), &buf.front(), buf.size());
if (len == 0) {
// ok, proc exit
@@ -132,4 +133,5 @@ Muxer::ReadMuxerAndSend(int waitTime) const
}
}
}
+}
diff --git a/p2pvr/lib/muxer.h b/p2pvr/lib/muxer.h
index 354f229..0888268 100644
--- a/p2pvr/lib/muxer.h
+++ b/p2pvr/lib/muxer.h
@@ -8,24 +8,26 @@
#include <visibility.h>
#include <logger.h>
-class DLL_PUBLIC Muxer : public P2PVR::RawDataClient {
+namespace P2PVR {
+class DLL_PUBLIC Muxer : public RawDataClient {
public:
- Muxer(const P2PVR::RawDataClientPrx & target, const std::string & cmd);
+ Muxer(const RawDataClientPrx & target, const std::string & cmd);
~Muxer();
- bool NewData(const P2PVR::Data &, const Ice::Current &);
+ bool NewData(const Data &, const Ice::Current &);
private:
DLL_PRIVATE bool ReadWaiting() const;
DLL_PRIVATE bool ReadAvailable() const;
DLL_PRIVATE bool ReadMuxerAndSend(int wait) const;
- const P2PVR::RawDataClientPrx target;
+ const RawDataClientPrx target;
typedef boost::shared_ptr<AdHoc::System::ProcessPipes> ProcessPipesPtr;
ProcessPipesPtr fds;
mutable std::mutex lock;
static IceTray::Logging::LoggerPtr log;
};
+}
#endif
diff --git a/p2pvr/lib/serviceStreamer.cpp b/p2pvr/lib/serviceStreamer.cpp
index 2729ca0..7e99008 100644
--- a/p2pvr/lib/serviceStreamer.cpp
+++ b/p2pvr/lib/serviceStreamer.cpp
@@ -1,6 +1,7 @@
#include "serviceStreamer.h"
-ServiceStreamer::ServiceStreamer(int sid, P2PVR::RawDataClientPrx t, const P2PVR::DevicesPrx & d, const P2PVR::SIPrx & s, const Ice::ObjectAdapterPtr & a) :
+namespace P2PVR {
+ServiceStreamer::ServiceStreamer(int sid, RawDataClientPrx t, const DevicesPrx & d, const SIPrx & s, const Ice::ObjectAdapterPtr & a) :
ServiceStreamerCore(sid, t, t, t, d, a),
si(s)
{
@@ -16,4 +17,5 @@ ServiceStreamer::Start()
const auto transport = si->GetDeliveryForService(serviceId);
ServiceStreamerCore::Start(transport);
}
+}
diff --git a/p2pvr/lib/serviceStreamer.h b/p2pvr/lib/serviceStreamer.h
index 230764e..bfed89a 100644
--- a/p2pvr/lib/serviceStreamer.h
+++ b/p2pvr/lib/serviceStreamer.h
@@ -4,18 +4,20 @@
#include "serviceStreamerCore.h"
#include <visibility.h>
+namespace P2PVR {
class DLL_PUBLIC ServiceStreamer : public ServiceStreamerCore {
public:
- ServiceStreamer(int sid, P2PVR::RawDataClientPrx, const P2PVR::DevicesPrx & d, const P2PVR::SIPrx & s, const Ice::ObjectAdapterPtr & a);
+ ServiceStreamer(int sid, RawDataClientPrx, const DevicesPrx & d, const SIPrx & s, const Ice::ObjectAdapterPtr & a);
~ServiceStreamer();
void Start();
private:
- P2PVR::SIPrx si;
+ SIPrx si;
};
typedef boost::shared_ptr<ServiceStreamer> ServiceStreamerPtr;
+}
#endif
diff --git a/p2pvr/lib/serviceStreamerCore.cpp b/p2pvr/lib/serviceStreamerCore.cpp
index 2667569..c6f637c 100644
--- a/p2pvr/lib/serviceStreamerCore.cpp
+++ b/p2pvr/lib/serviceStreamerCore.cpp
@@ -2,17 +2,18 @@
#include <boost/bind.hpp>
#include "bindSiParserHandler.h"
+namespace P2PVR {
IceTray::Logging::LoggerPtr ServiceStreamerCore::log(LOGMANAGER()->getLogger<ServiceStreamerCore>());
-ServiceStreamerCore::ServiceStreamerCore(int sid, P2PVR::RawDataClientPrx pat, P2PVR::RawDataClientPrx pmt, P2PVR::RawDataClientPrx ser,
- P2PVR::DevicesPrx d, Ice::ObjectAdapterPtr a) :
+ServiceStreamerCore::ServiceStreamerCore(int sid, RawDataClientPrx pat, RawDataClientPrx pmt, RawDataClientPrx ser,
+ DevicesPrx d, Ice::ObjectAdapterPtr a) :
adapter(a),
devs(d),
patTarget(pat),
pmtTarget(pmt),
serTarget(ser),
- patParser(adapter, new BindSiParserHandler<ProgramAssociationMapPtr, SiProgramAssociationParser>(boost::bind(&ServiceStreamerCore::HandlePAT, this, _1))),
- pmtParser(adapter, new BindSiParserHandler<DVBSI::ProgramMapPtr, SiProgramMapParser>(boost::bind(&ServiceStreamerCore::HandlePMT, this, _1))),
+ patParser(adapter, new DVBSI::BindSiParserHandler<DVBSI::ProgramAssociationMapPtr, DVBSI::SiProgramAssociationParser>(boost::bind(&ServiceStreamerCore::HandlePAT, this, _1))),
+ pmtParser(adapter, new DVBSI::BindSiParserHandler<::DVBSI::ProgramMapPtr, DVBSI::SiProgramMapParser>(boost::bind(&ServiceStreamerCore::HandlePMT, this, _1))),
serviceId(sid),
patHandle(0), pmtStream(0), pmtHandle(0), serviceHandle(0)
{
@@ -24,7 +25,7 @@ ServiceStreamerCore::~ServiceStreamerCore()
}
bool
-ServiceStreamerCore::HandlePAT(ProgramAssociationMapPtr pam)
+ServiceStreamerCore::HandlePAT(DVBSI::ProgramAssociationMapPtr pam)
{
const auto p = pam->find(serviceId);
if (p != pam->end() && p->second != pmtStream) {
@@ -38,7 +39,7 @@ ServiceStreamerCore::HandlePAT(ProgramAssociationMapPtr pam)
}
bool
-ServiceStreamerCore::HandlePMT(DVBSI::ProgramMapPtr pmp)
+ServiceStreamerCore::HandlePMT(::DVBSI::ProgramMapPtr pmp)
{
Streams strms;
for (const auto & s : pmp->Streams) {
@@ -50,14 +51,14 @@ ServiceStreamerCore::HandlePMT(DVBSI::ProgramMapPtr pmp)
streams = strms;
log->messagebf(LOG::DEBUG, "%s: Got ProgramMap, switching to %d streams", __PRETTY_FUNCTION__, streams.size());
stopHandle(serviceHandle);
- serviceHandle = tuner->StartSendingTS(P2PVR::PacketIds(streams.begin(), streams.end()), serTarget);
+ serviceHandle = tuner->StartSendingTS(PacketIds(streams.begin(), streams.end()), serTarget);
}
pmtTarget->NewData(pmtParser.Get()->CurrentRawData());
return false;
}
void
-ServiceStreamerCore::Start(DVBSI::DeliveryPtr transport)
+ServiceStreamerCore::Start(::DVBSI::DeliveryPtr transport)
{
tuner = devs->GetTunerSpecific(transport);
patHandle = tuner->StartSendingSection(0, patParser);
@@ -81,4 +82,5 @@ ServiceStreamerCore::stopHandle(int & handle)
handle = 0;
}
}
+}
diff --git a/p2pvr/lib/serviceStreamerCore.h b/p2pvr/lib/serviceStreamerCore.h
index 2654193..b53a656 100644
--- a/p2pvr/lib/serviceStreamerCore.h
+++ b/p2pvr/lib/serviceStreamerCore.h
@@ -11,28 +11,29 @@
#include <visibility.h>
#include <logger.h>
+namespace P2PVR {
class DLL_PUBLIC ServiceStreamerCore {
public:
- ServiceStreamerCore(int sid, P2PVR::RawDataClientPrx, P2PVR::RawDataClientPrx, P2PVR::RawDataClientPrx,
- P2PVR::DevicesPrx, Ice::ObjectAdapterPtr);
+ ServiceStreamerCore(int sid, RawDataClientPrx, RawDataClientPrx, RawDataClientPrx,
+ DevicesPrx, Ice::ObjectAdapterPtr);
virtual ~ServiceStreamerCore();
- void Start(DVBSI::DeliveryPtr);
+ void Start(::DVBSI::DeliveryPtr);
void Stop();
protected:
- bool HandlePAT(ProgramAssociationMapPtr pam);
- bool HandlePMT(DVBSI::ProgramMapPtr pmp);
+ bool HandlePAT(DVBSI::ProgramAssociationMapPtr pam);
+ bool HandlePMT(::DVBSI::ProgramMapPtr pmp);
void stopHandle(int & handle);
const Ice::ObjectAdapterPtr & adapter;
- P2PVR::DevicesPrx devs;
- P2PVR::RawDataClientPrx patTarget;
- P2PVR::RawDataClientPrx pmtTarget;
- P2PVR::RawDataClientPrx serTarget;
- TemporaryIceAdapterObject<SiTableParserBase> patParser;
- TemporaryIceAdapterObject<SiTableParserBase> pmtParser;
- P2PVR::TunerPrx tuner;
+ DevicesPrx devs;
+ RawDataClientPrx patTarget;
+ RawDataClientPrx pmtTarget;
+ RawDataClientPrx serTarget;
+ TemporaryIceAdapterObject<DVBSI::SiTableParserBase> patParser;
+ TemporaryIceAdapterObject<DVBSI::SiTableParserBase> pmtParser;
+ TunerPrx tuner;
int serviceId;
int patHandle;
@@ -44,6 +45,7 @@ class DLL_PUBLIC ServiceStreamerCore {
static IceTray::Logging::LoggerPtr log;
};
+}
#endif
diff --git a/p2pvr/lib/temporaryIceAdapterObject.h b/p2pvr/lib/temporaryIceAdapterObject.h
index 0614066..a11da53 100644
--- a/p2pvr/lib/temporaryIceAdapterObject.h
+++ b/p2pvr/lib/temporaryIceAdapterObject.h
@@ -4,6 +4,7 @@
#include <Ice/ObjectAdapter.h>
#include <visibility.h>
+namespace P2PVR {
template <typename Object>
class DLL_PUBLIC TemporaryIceAdapterObject {
public:
@@ -58,6 +59,7 @@ class DLL_PUBLIC TemporaryIceAdapterObject {
IceUtil::Handle<Object> object;
typename Object::ProxyType proxy;
};
+}
#endif