Move everything out of the global namespace

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