Move filepush from lib/base to lib/dvb
[openblackhole/openblackhole-enigma2.git] / lib / dvb / demux.h
1 #ifndef __dvb_demux_h
2 #define __dvb_demux_h
3
4 #include <aio.h>
5 #include <lib/dvb/idvb.h>
6 #include <lib/dvb/idemux.h>
7 #include <lib/dvb/pvrparse.h>
8 #include "filepush.h"
9
10 class eDVBDemux: public iDVBDemux
11 {
12         DECLARE_REF(eDVBDemux);
13 public:
14         enum {
15                 evtFlush
16         };
17         eDVBDemux(int adapter, int demux);
18         virtual ~eDVBDemux();
19
20         RESULT setSourceFrontend(int fenum);
21         int getSource() { return source; }
22         RESULT setSourcePVR(int pvrnum);
23
24         RESULT createSectionReader(eMainloop *context, ePtr<iDVBSectionReader> &reader);
25         RESULT createPESReader(eMainloop *context, ePtr<iDVBPESReader> &reader);
26         RESULT createTSRecorder(ePtr<iDVBTSRecorder> &recorder, int packetsize = 188, bool streaming=false);
27         RESULT getMPEGDecoder(ePtr<iTSMPEGDecoder> &reader, int index);
28         RESULT getSTC(pts_t &pts, int num);
29         RESULT getCADemuxID(uint8_t &id) { id = demux; return 0; }
30         RESULT getCAAdapterID(uint8_t &id) { id = adapter; return 0; }
31         RESULT flush();
32         RESULT connectEvent(const Slot1<void,int> &event, ePtr<eConnection> &conn);
33         int openDVR(int flags);
34
35         int getRefCount() { return ref; }
36 private:
37         int adapter, demux, source;
38
39         int m_dvr_busy;
40         friend class eDVBSectionReader;
41         friend class eDVBPESReader;
42         friend class eDVBAudio;
43         friend class eDVBVideo;
44         friend class eDVBPCR;
45         friend class eDVBTText;
46         friend class eDVBTSRecorder;
47         friend class eDVBCAService;
48         friend class eTSMPEGDecoder;
49         Signal1<void, int> m_event;
50
51         int openDemux(void);
52 };
53
54 class eDVBSectionReader: public iDVBSectionReader, public Object
55 {
56         DECLARE_REF(eDVBSectionReader);
57         int fd;
58         Signal1<void, const uint8_t*> read;
59         ePtr<eDVBDemux> demux;
60         int active;
61         int checkcrc;
62         void data(int);
63         ePtr<eSocketNotifier> notifier;
64 public:
65         eDVBSectionReader(eDVBDemux *demux, eMainloop *context, RESULT &res);
66         virtual ~eDVBSectionReader();
67         RESULT setBufferSize(int size);
68         RESULT start(const eDVBSectionFilterMask &mask);
69         RESULT stop();
70         RESULT connectRead(const Slot1<void,const uint8_t*> &read, ePtr<eConnection> &conn);
71 };
72
73 class eDVBPESReader: public iDVBPESReader, public Object
74 {
75         DECLARE_REF(eDVBPESReader);
76         int m_fd;
77         Signal2<void, const uint8_t*, int> m_read;
78         ePtr<eDVBDemux> m_demux;
79         int m_active;
80         void data(int);
81         ePtr<eSocketNotifier> m_notifier;
82 public:
83         eDVBPESReader(eDVBDemux *demux, eMainloop *context, RESULT &res);
84         virtual ~eDVBPESReader();
85         RESULT setBufferSize(int size);
86         RESULT start(int pid);
87         RESULT stop();
88         RESULT connectRead(const Slot2<void,const uint8_t*, int> &read, ePtr<eConnection> &conn);
89 };
90
91 class eDVBRecordFileThread: public eFilePushThreadRecorder
92 {
93 public:
94         eDVBRecordFileThread(int packetsize, int bufferCount);
95         ~eDVBRecordFileThread();
96         void setTimingPID(int pid, iDVBTSRecorder::timing_pid_type pidtype, int streamtype);
97         void startSaveMetaInformation(const std::string &filename);
98         void stopSaveMetaInformation();
99         int getLastPTS(pts_t &pts);
100         int getFirstPTS(pts_t &pts);
101         void setTargetFD(int fd) { m_fd_dest = fd; }
102         void enableAccessPoints(bool enable) { m_ts_parser.enableAccessPoints(enable); }
103 protected:
104         int asyncWrite(int len);
105         /* override */ int writeData(int len);
106         /* override */ void flush();
107
108         struct AsyncIO
109         {
110                 struct aiocb aio;
111                 unsigned char* buffer;
112                 AsyncIO()
113                 {
114                         memset(&aio, 0, sizeof(aiocb));
115                         buffer = NULL;
116                 }
117                 int wait();
118                 int start(int fd, off_t offset, size_t nbytes, void* buffer);
119                 int poll(); // returns 1 if busy, 0 if ready, <0 on error return
120                 int cancel(int fd); // returns <0 on error, 0 cancelled, >0 bytes written?
121         };
122         eMPEGStreamParserTS m_ts_parser;
123         off_t m_current_offset;
124         int m_fd_dest;
125         typedef std::vector<AsyncIO> AsyncIOvector;
126         unsigned char* m_allocated_buffer;
127         AsyncIOvector m_aio;
128         AsyncIOvector::iterator m_current_buffer;
129         std::vector<int> m_buffer_use_histogram;
130 };
131
132 class eDVBRecordStreamThread: public eDVBRecordFileThread
133 {
134 public:
135         eDVBRecordStreamThread(int packetsize):
136                 eDVBRecordFileThread(packetsize, /*bufferCount*/ 4)
137         {
138         }
139 protected:
140         int writeData(int len);
141         void flush();
142 };
143
144 class eDVBTSRecorder: public iDVBTSRecorder, public Object
145 {
146         DECLARE_REF(eDVBTSRecorder);
147 public:
148         eDVBTSRecorder(eDVBDemux *demux, int packetsize, bool streaming);
149         ~eDVBTSRecorder();
150
151         RESULT setBufferSize(int size);
152         RESULT start();
153         RESULT addPID(int pid);
154         RESULT removePID(int pid);
155
156         RESULT setTimingPID(int pid, timing_pid_type pidtype, int streamtype);
157
158         RESULT setTargetFD(int fd);
159         RESULT setTargetFilename(const std::string& filename);
160         RESULT setBoundary(off_t max);
161         RESULT enableAccessPoints(bool enable);
162
163         RESULT stop();
164
165         RESULT getCurrentPCR(pts_t &pcr);
166         RESULT getFirstPTS(pts_t &pts);
167
168         RESULT connectEvent(const Slot1<void,int> &event, ePtr<eConnection> &conn);
169 private:
170         RESULT startPID(int pid);
171         void stopPID(int pid);
172
173         void filepushEvent(int event);
174
175         std::map<int,int> m_pids;
176         Signal1<void,int> m_event;
177
178         ePtr<eDVBDemux> m_demux;
179
180         int m_running;
181         int m_target_fd;
182         int m_source_fd;
183         eDVBRecordFileThread *m_thread;
184         std::string m_target_filename;
185         int m_packetsize;
186 };
187
188 #endif