summaryrefslogtreecommitdiff
path: root/p2pvr/devices/tuner.h
blob: b4d92b3773a578110ade2076fa6a9a8700a13b61 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
#ifndef P2PVR_TUNER_H
#define P2PVR_TUNER_H

#include <dvb.h>
#include <boost/filesystem/path.hpp>
#include <fileUtils.h>
#include "frontend.h"
#include <map>
#include <thread>
#include <mutex>
#include <boost/bind.hpp>
#include <boost/function.hpp>
#include <boost/tuple/tuple.hpp>
#include <options.h>
#include <logger.h>

namespace P2PVR {
namespace DVB {
namespace Frontends {
	class OFDM;
}

class Tuner : public PrivateTuner {
	public:
		class IDataSender {
			public:
				IDataSender(const RawDataClientPrx &);
				virtual ~IDataSender() = 0;

				virtual void NewData(const Data &) = 0;
				virtual bool IsFinished() = 0;
				uint64_t PacketsSent() const;

			protected:
				uint64_t _packetsSent;
				const RawDataClientPrx client;
		};
		typedef boost::shared_ptr<IDataSender> BackgroundClient;
		typedef std::map<int, BackgroundClient> BackgroundClients;

		Tuner(const boost::filesystem::path & deviceFrontend);
		~Tuner();

		void TuneTo(const DVBSI::DeliveryPtr &, const Ice::Current&);
		int GetStatus(const Ice::Current&);
		std::string Device() const;

		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 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 RawDataClientPrx & client, const Ice::Current &) const;
		void RequestPID(int pid, int fd) const;
		uint64_t ReadDemuxAndSend(int fd, const RawDataClientPrx & client) const;
		void startSenderThread();
		void senderThread();
		static void setBufferSize(int fd, unsigned long bytes);

		const boost::filesystem::path deviceFrontend;
		const boost::filesystem::path deviceRoot;
		AdHoc::FileUtils::FileHandle frontendFD;
		BackgroundClients backgroundClients;
		std::thread * backgroundThread;
		std::mutex lock;

		mutable time_t lastUsedTime;
		FrontendPtr frontend;
		static IceTray::Logging::LoggerPtr logger;

	public:
		class Options : public IceTray::Options {
			public:
				Options();

				ICETRAY_OPTIONS_DECLARE;

				int TuningTimeout;
				int LockTimeout;
				int DemuxReadTimeout;
				int DemuxTableBufferSize;
				int DemuxStreamBufferSize;
		};

	private:
		friend class Frontend;
		friend class Frontends::OFDM;
		IceTray::OptionsResolver<Options> options;
};
}
}

#endif