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