b92ee2570675e9c9d6d718d356f74fddc91e302e
[enigma2.git] / lib / service / servicedvbrecord.cpp
1 #include <lib/service/servicedvbrecord.h>
2 #include <lib/base/eerror.h>
3 #include <lib/dvb/epgcache.h>
4 #include <fcntl.h>
5
6 DEFINE_REF(eDVBServiceRecord);
7
8 eDVBServiceRecord::eDVBServiceRecord(const eServiceReferenceDVB &ref): m_ref(ref)
9 {
10         CONNECT(m_service_handler.serviceEvent, eDVBServiceRecord::serviceEvent);
11         m_state = stateIdle;
12         m_want_record = 0;
13         m_tuned = 0;
14         m_target_fd = -1;
15         m_error = 0;
16         m_streaming = 0;
17         m_simulate = false;
18 }
19
20 void eDVBServiceRecord::serviceEvent(int event)
21 {
22         eDebug("RECORD service event %d", event);
23         switch (event)
24         {
25         case eDVBServicePMTHandler::eventTuned:
26         {
27                 eDebug("tuned..");
28                 m_tuned = 1;
29                 if (m_state == stateRecording && m_want_record)
30                         doRecord();
31                 m_event((iRecordableService*)this, evTunedIn);
32                 break;
33         }
34         case eDVBServicePMTHandler::eventTuneFailed:
35         {
36                 eDebug("record failed to tune");
37                 m_event((iRecordableService*)this, evTuneFailed);
38                 break;
39         }
40         case eDVBServicePMTHandler::eventNewProgramInfo:
41         {
42                 if (m_state == stateIdle)
43                         doPrepare();
44                 else if (m_want_record) /* doRecord can be called from Prepared and Recording state */
45                         doRecord();
46                 m_event((iRecordableService*)this, evNewProgramInfo);
47                 break;
48         }
49         case eDVBServicePMTHandler::eventMisconfiguration:
50                 m_error = errMisconfiguration;
51                 m_event((iRecordableService*)this, evTuneFailed);
52                 break;
53         case eDVBServicePMTHandler::eventNoResources:
54                 m_error = errNoResources;
55                 m_event((iRecordableService*)this, evTuneFailed);
56                 break;
57         }
58 }
59
60 RESULT eDVBServiceRecord::prepare(const char *filename, time_t begTime, time_t endTime, int eit_event_id)
61 {
62         m_filename = filename;
63         m_streaming = 0;
64         
65         if (m_state == stateIdle)
66         {
67                 int ret = doPrepare();
68                 if (!ret)
69                 {
70                         eEPGCache::getInstance()->Lock();
71                         const eit_event_struct *event = 0;
72                         eServiceReferenceDVB ref = m_ref.getParentServiceReference();
73                         if (!ref.valid())
74                                 ref = m_ref;
75                         if ( eit_event_id != -1 )
76                         {
77                                 eDebug("query epg event id %d", eit_event_id);
78                                 eEPGCache::getInstance()->lookupEventId(ref, eit_event_id, event);
79                         }
80                         if ( !event && (begTime != -1 && endTime != -1) )
81                         {
82                                 time_t queryTime = begTime + ((endTime-begTime)/2);
83                                 tm beg, end, query;
84                                 localtime_r(&begTime, &beg);
85                                 localtime_r(&endTime, &end);
86                                 localtime_r(&queryTime, &query);
87                                 eDebug("query stime %d:%d:%d, etime %d:%d:%d, qtime %d:%d:%d",
88                                         beg.tm_hour, beg.tm_min, beg.tm_sec,
89                                         end.tm_hour, end.tm_min, end.tm_sec,
90                                         query.tm_hour, query.tm_min, query.tm_sec);
91                                 eEPGCache::getInstance()->lookupEventTime(ref, queryTime, event);
92                         }
93                         if ( event )
94                         {
95                                 eDebug("found event.. store to disc");
96                                 std::string fname = filename;
97                                 fname.erase(fname.length()-2, 2);
98                                 fname+="eit";
99                                 int fd = open(fname.c_str(), O_CREAT|O_WRONLY, 0777);
100                                 if (fd>-1)
101                                 {
102                                         int evLen=HILO(event->descriptors_loop_length)+12/*EIT_LOOP_SIZE*/;
103                                         int wr = ::write( fd, (unsigned char*)event, evLen );
104                                         if ( wr != evLen )
105                                                 eDebug("eit write error (%m)");
106                                         ::close(fd);
107                                 }
108                         }
109                         eEPGCache::getInstance()->Unlock();
110                 }
111                 return ret;
112         }
113         else
114                 return -1;
115 }
116
117 RESULT eDVBServiceRecord::prepareStreaming()
118 {
119         m_filename = "";
120         m_streaming = 1;
121         if (m_state == stateIdle)
122                 return doPrepare();
123         return -1;
124 }
125
126 RESULT eDVBServiceRecord::start(bool simulate)
127 {
128         m_simulate = simulate;
129         m_want_record = 1;
130                 /* when tune wasn't yet successfully, doRecord stays in "prepared"-state which is fine. */
131         m_event((iRecordableService*)this, evStart);
132         return doRecord();
133 }
134
135 RESULT eDVBServiceRecord::stop()
136 {
137         if (!m_simulate)
138                 eDebug("stop recording!");
139         if (m_state == stateRecording)
140         {
141                 if (m_record)
142                         m_record->stop();
143                 if (m_target_fd >= 0)
144                 {
145                         ::close(m_target_fd);
146                         m_target_fd = -1;
147                 }
148                 m_state = statePrepared;
149         } else if (!m_simulate)
150                 eDebug("(was not recording)");
151         if (m_state == statePrepared)
152         {
153                 m_record = 0;
154                 m_state = stateIdle;
155         }
156         m_event((iRecordableService*)this, evRecordStopped);
157         return 0;
158 }
159
160 int eDVBServiceRecord::doPrepare()
161 {
162                 /* allocate a ts recorder if we don't already have one. */
163         if (m_state == stateIdle)
164         {
165                 m_pids_active.clear();
166                 m_state = statePrepared;
167                 return m_service_handler.tune(m_ref, 0, 0, m_simulate);
168         }
169         return 0;
170 }
171
172 int eDVBServiceRecord::doRecord()
173 {
174         int err = doPrepare();
175         if (err)
176         {
177                 m_error = errTuneFailed;
178                 m_event((iRecordableService*)this, evRecordFailed);
179                 return err;
180         }
181         
182         if (!m_tuned)
183                 return 0; /* try it again when we are tuned in */
184         
185         if (!m_record && m_tuned && !m_streaming && !m_simulate)
186         {
187                 eDebug("Recording to %s...", m_filename.c_str());
188                 ::remove(m_filename.c_str());
189                 int fd = ::open(m_filename.c_str(), O_WRONLY|O_CREAT|O_LARGEFILE, 0644);
190                 if (fd == -1)
191                 {
192                         eDebug("eDVBServiceRecord - can't open recording file!");
193                         m_error = errOpenRecordFile;
194                         m_event((iRecordableService*)this, evRecordFailed);
195                         return errOpenRecordFile;
196                 }
197
198                         /* turn off kernel caching strategies */
199                 posix_fadvise(fd, 0, 0, POSIX_FADV_RANDOM);
200
201                 ePtr<iDVBDemux> demux;
202                 if (m_service_handler.getDataDemux(demux))
203                 {
204                         eDebug("eDVBServiceRecord - NO DEMUX available!");
205                         m_error = errNoDemuxAvailable;
206                         m_event((iRecordableService*)this, evRecordFailed);
207                         return errNoDemuxAvailable;
208                 }
209                 demux->createTSRecorder(m_record);
210                 if (!m_record)
211                 {
212                         eDebug("eDVBServiceRecord - no ts recorder available.");
213                         m_error = errNoTsRecorderAvailable;
214                         m_event((iRecordableService*)this, evRecordFailed);
215                         return errNoTsRecorderAvailable;
216                 }
217                 m_record->setTargetFD(fd);
218                 m_record->setTargetFilename(m_filename.c_str());
219                 m_record->connectEvent(slot(*this, &eDVBServiceRecord::recordEvent), m_con_record_event);
220
221                 m_target_fd = fd;
222         }
223         
224         if (m_streaming)
225         {
226                 m_state = stateRecording;
227                 eDebug("start streaming...");
228         } else
229         {
230                 eDebug("start recording...");
231
232                 eDVBServicePMTHandler::program program;
233                 if (m_service_handler.getProgramInfo(program))
234                         eDebug("getting program info failed.");
235                 else
236                 {
237                         std::set<int> pids_to_record;
238
239                         pids_to_record.insert(0); // PAT
240
241                         if (program.pmtPid != -1)
242                                 pids_to_record.insert(program.pmtPid); // PMT
243
244                         int timing_pid = -1;
245
246                         eDebugNoNewLine("RECORD: have %d video stream(s)", program.videoStreams.size());
247                         if (!program.videoStreams.empty())
248                         {
249                                 eDebugNoNewLine(" (");
250                                 for (std::vector<eDVBServicePMTHandler::videoStream>::const_iterator
251                                         i(program.videoStreams.begin()); 
252                                         i != program.videoStreams.end(); ++i)
253                                 {
254                                         pids_to_record.insert(i->pid);
255                                         
256                                         if (timing_pid == -1)
257                                                 timing_pid = i->pid;
258                                         
259                                         if (i != program.videoStreams.begin())
260                                                         eDebugNoNewLine(", ");
261                                         eDebugNoNewLine("%04x", i->pid);
262                                 }
263                                 eDebugNoNewLine(")");
264                         }
265                         eDebugNoNewLine(", and %d audio stream(s)", program.audioStreams.size());
266                         if (!program.audioStreams.empty())
267                         {
268                                 eDebugNoNewLine(" (");
269                                 for (std::vector<eDVBServicePMTHandler::audioStream>::const_iterator
270                                         i(program.audioStreams.begin()); 
271                                         i != program.audioStreams.end(); ++i)
272                                 {
273                                         pids_to_record.insert(i->pid);
274         
275                                         if (timing_pid == -1)
276                                                 timing_pid = i->pid;
277                                 
278                                         if (i != program.audioStreams.begin())
279                                                 eDebugNoNewLine(", ");
280                                         eDebugNoNewLine("%04x", i->pid);
281                                 }
282                                 eDebugNoNewLine(")");
283                         }
284                         if (!program.subtitleStreams.empty())
285                         {
286                                 eDebugNoNewLine(" (");
287                                 for (std::vector<eDVBServicePMTHandler::subtitleStream>::const_iterator
288                                         i(program.subtitleStreams.begin());
289                                         i != program.subtitleStreams.end(); ++i)
290                                 {
291                                         pids_to_record.insert(i->pid);
292         
293                                         if (i != program.subtitleStreams.begin())
294                                                 eDebugNoNewLine(", ");
295                                         eDebugNoNewLine("%04x", i->pid);
296                                 }
297                                 eDebugNoNewLine(")");
298                         }
299                         eDebugNoNewLine(", and the pcr pid is %04x", program.pcrPid);
300                         if (program.pcrPid != 0x1fff)
301                                 pids_to_record.insert(program.pcrPid);
302                         eDebug(", and the text pid is %04x", program.textPid);
303                         if (program.textPid != -1)
304                                 pids_to_record.insert(program.textPid); // Videotext
305
306                                 /* find out which pids are NEW and which pids are obsolete.. */
307                         std::set<int> new_pids, obsolete_pids;
308
309                         std::set_difference(pids_to_record.begin(), pids_to_record.end(), 
310                                         m_pids_active.begin(), m_pids_active.end(),
311                                         std::inserter(new_pids, new_pids.begin()));
312
313                         std::set_difference(
314                                         m_pids_active.begin(), m_pids_active.end(),
315                                         pids_to_record.begin(), pids_to_record.end(), 
316                                         std::inserter(new_pids, new_pids.begin())
317                                         );
318                         
319                         for (std::set<int>::iterator i(new_pids.begin()); i != new_pids.end(); ++i)
320                         {
321                                 eDebug("ADD PID: %04x", *i);
322                                 m_record->addPID(*i);
323                         }
324
325                         for (std::set<int>::iterator i(obsolete_pids.begin()); i != obsolete_pids.end(); ++i)
326                         {
327                                 eDebug("REMOVED PID: %04x", *i);
328                                 m_record->removePID(*i);
329                         }
330
331                         if (timing_pid != -1)
332                                 m_record->setTimingPID(timing_pid);
333
334                         m_pids_active = pids_to_record;
335
336                         if (m_state != stateRecording)
337                         {
338                                 m_record->start();
339                                 m_state = stateRecording;
340                         }
341                 }
342         }
343         m_error = 0;
344         m_event((iRecordableService*)this, evRecordRunning);
345         return 0;
346 }
347
348 RESULT eDVBServiceRecord::frontendInfo(ePtr<iFrontendInformation> &ptr)
349 {
350         ptr = this;
351         return 0;
352 }
353
354 RESULT eDVBServiceRecord::connectEvent(const Slot2<void,iRecordableService*,int> &event, ePtr<eConnection> &connection)
355 {
356         connection = new eConnection((iRecordableService*)this, m_event.connect(event));
357         return 0;
358 }
359
360 RESULT eDVBServiceRecord::stream(ePtr<iStreamableService> &ptr)
361 {
362         ptr = this;
363         return 0;
364 }
365
366 extern void PutToDict(ePyObject &dict, const char*key, long val);  // defined in dvb/frontend.cpp
367
368 PyObject *eDVBServiceRecord::getStreamingData()
369 {
370         eDVBServicePMTHandler::program program;
371         if (!m_tuned || m_service_handler.getProgramInfo(program))
372         {
373                 Py_RETURN_NONE;
374         }
375
376         ePyObject r = program.createPythonObject();
377         ePtr<iDVBDemux> demux;
378         if (!m_service_handler.getDataDemux(demux))
379         {
380                 uint8_t demux_id;
381                 if (!demux->getCADemuxID(demux_id))
382                         PutToDict(r, "demux", demux_id);
383         }
384
385         return r;
386 }
387
388 void eDVBServiceRecord::recordEvent(int event)
389 {
390         switch (event)
391         {
392         case iDVBTSRecorder::eventWriteError:
393                 eWarning("[eDVBServiceRecord] record write error");
394                 stop();
395                 m_event((iRecordableService*)this, evRecordWriteError);
396                 return;
397         default:
398                 eDebug("unhandled record event %d", event);
399         }
400 }