insert cutmark on EIT change
[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         /* for cutlist */
7 #include <byteswap.h>
8 #include <netinet/in.h>
9
10 #ifndef BYTE_ORDER
11 #error no byte order defined!
12 #endif
13
14 DEFINE_REF(eDVBServiceRecord);
15
16 eDVBServiceRecord::eDVBServiceRecord(const eServiceReferenceDVB &ref): m_ref(ref)
17 {
18         CONNECT(m_service_handler.serviceEvent, eDVBServiceRecord::serviceEvent);
19         CONNECT(m_event_handler.m_eit_changed, eDVBServiceRecord::gotNewEvent);
20         m_state = stateIdle;
21         m_want_record = 0;
22         m_tuned = 0;
23         m_target_fd = -1;
24         m_error = 0;
25         m_streaming = 0;
26         m_simulate = false;
27         m_last_event_id = -1;
28 }
29
30 void eDVBServiceRecord::serviceEvent(int event)
31 {
32         eDebug("RECORD service event %d", event);
33         switch (event)
34         {
35         case eDVBServicePMTHandler::eventTuned:
36         {
37                 eDebug("tuned..");
38                 m_tuned = 1;
39
40                         /* start feeding EIT updates */
41                 ePtr<iDVBDemux> m_demux;
42                 if (!m_service_handler.getDataDemux(m_demux))
43                 {
44                         eServiceReferenceDVB &ref = (eServiceReferenceDVB&) m_ref;
45                         int sid = ref.getParentServiceID().get();
46                         if (!sid)
47                                 sid = ref.getServiceID().get();
48                         if ( ref.getParentTransportStreamID().get() &&
49                                 ref.getParentTransportStreamID() != ref.getTransportStreamID() )
50                                 m_event_handler.startOther(m_demux, sid);
51                         else
52                                 m_event_handler.start(m_demux, sid);
53                 }
54
55                 if (m_state == stateRecording && m_want_record)
56                         doRecord();
57                 m_event((iRecordableService*)this, evTunedIn);
58                 break;
59         }
60         case eDVBServicePMTHandler::eventTuneFailed:
61         {
62                 eDebug("record failed to tune");
63                 m_event((iRecordableService*)this, evTuneFailed);
64                 break;
65         }
66         case eDVBServicePMTHandler::eventNewProgramInfo:
67         {
68                 if (m_state == stateIdle)
69                         doPrepare();
70                 else if (m_want_record) /* doRecord can be called from Prepared and Recording state */
71                         doRecord();
72                 m_event((iRecordableService*)this, evNewProgramInfo);
73                 break;
74         }
75         case eDVBServicePMTHandler::eventMisconfiguration:
76                 m_error = errMisconfiguration;
77                 m_event((iRecordableService*)this, evTuneFailed);
78                 break;
79         case eDVBServicePMTHandler::eventNoResources:
80                 m_error = errNoResources;
81                 m_event((iRecordableService*)this, evTuneFailed);
82                 break;
83         }
84 }
85
86 RESULT eDVBServiceRecord::prepare(const char *filename, time_t begTime, time_t endTime, int eit_event_id)
87 {
88         m_filename = filename;
89         m_streaming = 0;
90         
91         if (m_state == stateIdle)
92         {
93                 int ret = doPrepare();
94                 if (!ret)
95                 {
96                         eEPGCache::getInstance()->Lock();
97                         const eit_event_struct *event = 0;
98                         eServiceReferenceDVB ref = m_ref.getParentServiceReference();
99                         if (!ref.valid())
100                                 ref = m_ref;
101                         if ( eit_event_id != -1 )
102                         {
103                                 eDebug("query epg event id %d", eit_event_id);
104                                 eEPGCache::getInstance()->lookupEventId(ref, eit_event_id, event);
105                         }
106                         if ( !event && (begTime != -1 && endTime != -1) )
107                         {
108                                 time_t queryTime = begTime + ((endTime-begTime)/2);
109                                 tm beg, end, query;
110                                 localtime_r(&begTime, &beg);
111                                 localtime_r(&endTime, &end);
112                                 localtime_r(&queryTime, &query);
113                                 eDebug("query stime %d:%d:%d, etime %d:%d:%d, qtime %d:%d:%d",
114                                         beg.tm_hour, beg.tm_min, beg.tm_sec,
115                                         end.tm_hour, end.tm_min, end.tm_sec,
116                                         query.tm_hour, query.tm_min, query.tm_sec);
117                                 eEPGCache::getInstance()->lookupEventTime(ref, queryTime, event);
118                         }
119                         if ( event )
120                         {
121                                 eDebug("found event.. store to disc");
122                                 std::string fname = filename;
123                                 fname.erase(fname.length()-2, 2);
124                                 fname+="eit";
125                                 int fd = open(fname.c_str(), O_CREAT|O_WRONLY, 0777);
126                                 if (fd>-1)
127                                 {
128                                         int evLen=HILO(event->descriptors_loop_length)+12/*EIT_LOOP_SIZE*/;
129                                         int wr = ::write( fd, (unsigned char*)event, evLen );
130                                         if ( wr != evLen )
131                                                 eDebug("eit write error (%m)");
132                                         ::close(fd);
133                                 }
134                         }
135                         eEPGCache::getInstance()->Unlock();
136                 }
137                 return ret;
138         }
139         else
140                 return -1;
141 }
142
143 RESULT eDVBServiceRecord::prepareStreaming()
144 {
145         m_filename = "";
146         m_streaming = 1;
147         if (m_state == stateIdle)
148                 return doPrepare();
149         return -1;
150 }
151
152 RESULT eDVBServiceRecord::start(bool simulate)
153 {
154         m_simulate = simulate;
155         m_want_record = 1;
156                 /* when tune wasn't yet successfully, doRecord stays in "prepared"-state which is fine. */
157         m_event((iRecordableService*)this, evStart);
158         return doRecord();
159 }
160
161 RESULT eDVBServiceRecord::stop()
162 {
163         if (!m_simulate)
164                 eDebug("stop recording!");
165         if (m_state == stateRecording)
166         {
167                 if (m_record)
168                         m_record->stop();
169                 if (m_target_fd >= 0)
170                 {
171                         ::close(m_target_fd);
172                         m_target_fd = -1;
173                 }
174                 
175                 saveCutlist();
176                 
177                 m_state = statePrepared;
178         } else if (!m_simulate)
179                 eDebug("(was not recording)");
180         if (m_state == statePrepared)
181         {
182                 m_record = 0;
183                 m_state = stateIdle;
184         }
185         m_event((iRecordableService*)this, evRecordStopped);
186         return 0;
187 }
188
189 int eDVBServiceRecord::doPrepare()
190 {
191                 /* allocate a ts recorder if we don't already have one. */
192         if (m_state == stateIdle)
193         {
194                 m_pids_active.clear();
195                 m_state = statePrepared;
196                 return m_service_handler.tune(m_ref, 0, 0, m_simulate);
197         }
198         return 0;
199 }
200
201 int eDVBServiceRecord::doRecord()
202 {
203         int err = doPrepare();
204         if (err)
205         {
206                 m_error = errTuneFailed;
207                 m_event((iRecordableService*)this, evRecordFailed);
208                 return err;
209         }
210         
211         if (!m_tuned)
212                 return 0; /* try it again when we are tuned in */
213         
214         if (!m_record && m_tuned && !m_streaming && !m_simulate)
215         {
216                 eDebug("Recording to %s...", m_filename.c_str());
217                 ::remove(m_filename.c_str());
218                 int fd = ::open(m_filename.c_str(), O_WRONLY|O_CREAT|O_LARGEFILE, 0644);
219                 if (fd == -1)
220                 {
221                         eDebug("eDVBServiceRecord - can't open recording file!");
222                         m_error = errOpenRecordFile;
223                         m_event((iRecordableService*)this, evRecordFailed);
224                         return errOpenRecordFile;
225                 }
226
227                         /* turn off kernel caching strategies */
228                 posix_fadvise(fd, 0, 0, POSIX_FADV_RANDOM);
229
230                 ePtr<iDVBDemux> demux;
231                 if (m_service_handler.getDataDemux(demux))
232                 {
233                         eDebug("eDVBServiceRecord - NO DEMUX available!");
234                         m_error = errNoDemuxAvailable;
235                         m_event((iRecordableService*)this, evRecordFailed);
236                         return errNoDemuxAvailable;
237                 }
238                 demux->createTSRecorder(m_record);
239                 if (!m_record)
240                 {
241                         eDebug("eDVBServiceRecord - no ts recorder available.");
242                         m_error = errNoTsRecorderAvailable;
243                         m_event((iRecordableService*)this, evRecordFailed);
244                         return errNoTsRecorderAvailable;
245                 }
246                 m_record->setTargetFD(fd);
247                 m_record->setTargetFilename(m_filename.c_str());
248                 m_record->connectEvent(slot(*this, &eDVBServiceRecord::recordEvent), m_con_record_event);
249
250                 m_target_fd = fd;
251         }
252         
253         if (m_streaming)
254         {
255                 m_state = stateRecording;
256                 eDebug("start streaming...");
257         } else
258         {
259                 eDebug("start recording...");
260
261                 eDVBServicePMTHandler::program program;
262                 if (m_service_handler.getProgramInfo(program))
263                         eDebug("getting program info failed.");
264                 else
265                 {
266                         std::set<int> pids_to_record;
267
268                         pids_to_record.insert(0); // PAT
269
270                         if (program.pmtPid != -1)
271                                 pids_to_record.insert(program.pmtPid); // PMT
272
273                         int timing_pid = -1;
274
275                         eDebugNoNewLine("RECORD: have %d video stream(s)", program.videoStreams.size());
276                         if (!program.videoStreams.empty())
277                         {
278                                 eDebugNoNewLine(" (");
279                                 for (std::vector<eDVBServicePMTHandler::videoStream>::const_iterator
280                                         i(program.videoStreams.begin()); 
281                                         i != program.videoStreams.end(); ++i)
282                                 {
283                                         pids_to_record.insert(i->pid);
284                                         
285                                         if (timing_pid == -1)
286                                                 timing_pid = i->pid;
287                                         
288                                         if (i != program.videoStreams.begin())
289                                                         eDebugNoNewLine(", ");
290                                         eDebugNoNewLine("%04x", i->pid);
291                                 }
292                                 eDebugNoNewLine(")");
293                         }
294                         eDebugNoNewLine(", and %d audio stream(s)", program.audioStreams.size());
295                         if (!program.audioStreams.empty())
296                         {
297                                 eDebugNoNewLine(" (");
298                                 for (std::vector<eDVBServicePMTHandler::audioStream>::const_iterator
299                                         i(program.audioStreams.begin()); 
300                                         i != program.audioStreams.end(); ++i)
301                                 {
302                                         pids_to_record.insert(i->pid);
303         
304                                         if (timing_pid == -1)
305                                                 timing_pid = i->pid;
306                                 
307                                         if (i != program.audioStreams.begin())
308                                                 eDebugNoNewLine(", ");
309                                         eDebugNoNewLine("%04x", i->pid);
310                                 }
311                                 eDebugNoNewLine(")");
312                         }
313                         if (!program.subtitleStreams.empty())
314                         {
315                                 eDebugNoNewLine(" (");
316                                 for (std::vector<eDVBServicePMTHandler::subtitleStream>::const_iterator
317                                         i(program.subtitleStreams.begin());
318                                         i != program.subtitleStreams.end(); ++i)
319                                 {
320                                         pids_to_record.insert(i->pid);
321         
322                                         if (i != program.subtitleStreams.begin())
323                                                 eDebugNoNewLine(", ");
324                                         eDebugNoNewLine("%04x", i->pid);
325                                 }
326                                 eDebugNoNewLine(")");
327                         }
328                         eDebugNoNewLine(", and the pcr pid is %04x", program.pcrPid);
329                         if (program.pcrPid != 0x1fff)
330                                 pids_to_record.insert(program.pcrPid);
331                         eDebug(", and the text pid is %04x", program.textPid);
332                         if (program.textPid != -1)
333                                 pids_to_record.insert(program.textPid); // Videotext
334
335                                 /* find out which pids are NEW and which pids are obsolete.. */
336                         std::set<int> new_pids, obsolete_pids;
337
338                         std::set_difference(pids_to_record.begin(), pids_to_record.end(), 
339                                         m_pids_active.begin(), m_pids_active.end(),
340                                         std::inserter(new_pids, new_pids.begin()));
341
342                         std::set_difference(
343                                         m_pids_active.begin(), m_pids_active.end(),
344                                         pids_to_record.begin(), pids_to_record.end(), 
345                                         std::inserter(new_pids, new_pids.begin())
346                                         );
347                         
348                         for (std::set<int>::iterator i(new_pids.begin()); i != new_pids.end(); ++i)
349                         {
350                                 eDebug("ADD PID: %04x", *i);
351                                 m_record->addPID(*i);
352                         }
353
354                         for (std::set<int>::iterator i(obsolete_pids.begin()); i != obsolete_pids.end(); ++i)
355                         {
356                                 eDebug("REMOVED PID: %04x", *i);
357                                 m_record->removePID(*i);
358                         }
359
360                         if (timing_pid != -1)
361                                 m_record->setTimingPID(timing_pid);
362
363                         m_pids_active = pids_to_record;
364
365                         if (m_state != stateRecording)
366                         {
367                                 m_record->start();
368                                 m_state = stateRecording;
369                         }
370                 }
371         }
372         m_error = 0;
373         m_event((iRecordableService*)this, evRecordRunning);
374         return 0;
375 }
376
377 RESULT eDVBServiceRecord::frontendInfo(ePtr<iFrontendInformation> &ptr)
378 {
379         ptr = this;
380         return 0;
381 }
382
383 RESULT eDVBServiceRecord::connectEvent(const Slot2<void,iRecordableService*,int> &event, ePtr<eConnection> &connection)
384 {
385         connection = new eConnection((iRecordableService*)this, m_event.connect(event));
386         return 0;
387 }
388
389 RESULT eDVBServiceRecord::stream(ePtr<iStreamableService> &ptr)
390 {
391         ptr = this;
392         return 0;
393 }
394
395 extern void PutToDict(ePyObject &dict, const char*key, long val);  // defined in dvb/frontend.cpp
396
397 PyObject *eDVBServiceRecord::getStreamingData()
398 {
399         eDVBServicePMTHandler::program program;
400         if (!m_tuned || m_service_handler.getProgramInfo(program))
401         {
402                 Py_RETURN_NONE;
403         }
404
405         ePyObject r = program.createPythonObject();
406         ePtr<iDVBDemux> demux;
407         if (!m_service_handler.getDataDemux(demux))
408         {
409                 uint8_t demux_id;
410                 if (!demux->getCADemuxID(demux_id))
411                         PutToDict(r, "demux", demux_id);
412         }
413
414         return r;
415 }
416
417 void eDVBServiceRecord::recordEvent(int event)
418 {
419         switch (event)
420         {
421         case iDVBTSRecorder::eventWriteError:
422                 eWarning("[eDVBServiceRecord] record write error");
423                 stop();
424                 m_event((iRecordableService*)this, evRecordWriteError);
425                 return;
426         default:
427                 eDebug("unhandled record event %d", event);
428         }
429 }
430
431 void eDVBServiceRecord::gotNewEvent()
432 {
433         ePtr<eServiceEvent> event_now;
434         m_event_handler.getEvent(event_now, 0);
435
436         if (!event_now)
437                 return;
438
439         int event_id = event_now->getEventId();
440
441         pts_t p;
442         
443         if (m_record)
444         {
445                 if (m_record->getCurrentPCR(p))
446                         eDebug("getting PCR failed!");
447                 else
448                 {
449                         static int i;
450                         m_event_timestamps[/* event_id*/ ++i] = p;
451                         eDebug("pcr of eit change: %llx", p);
452                 }
453         }
454
455         if (event_id != m_last_event_id)
456                 eDebug("[eDVBServiceRecord] now running: %s (%d seconds)", event_now->getEventName().c_str(), event_now->getDuration());
457         
458         m_last_event_id = event_id;
459 }
460
461 void eDVBServiceRecord::saveCutlist()
462 {
463                         /* XXX: dupe of eDVBServicePlay::saveCuesheet, refactor plz */
464         std::string filename = m_filename + ".cuts";
465
466         eDVBTSTools tstools;
467         
468         if (tstools.openFile(m_filename.c_str()))
469         {
470                 eDebug("[eDVBServiceRecord] saving cutlist failed because tstools failed");
471                 return;
472         }
473         
474         FILE *f = fopen(filename.c_str(), "wb");
475
476         if (f)
477         {
478                 unsigned long long where;
479                 int what;
480
481                 for (std::map<int,pts_t>::iterator i(m_event_timestamps.begin()); i != m_event_timestamps.end(); ++i)
482                 {
483                         pts_t p = i->second;
484                         off_t offset = 0; // fixme, we need to note down both
485                         if (tstools.fixupPTS(offset, p))
486                         {
487                                 eDebug("[eDVBServiceRecord] fixing up PTS failed, not saving");
488                                 continue;
489                         }
490                         eDebug("fixed up %llx to %llx (offset %llx)", i->second, p, offset);
491 #if BYTE_ORDER == BIG_ENDIAN
492                         where = p;
493 #else
494                         where = bswap_64(p);
495 #endif
496                         what = htonl(2); /* mark */
497                         fwrite(&where, sizeof(where), 1, f);
498                         fwrite(&what, sizeof(what), 1, f);
499                 }
500                 fclose(f);
501         }
502         
503 }