1 #include <lib/service/servicedvbrecord.h>
2 #include <lib/base/eerror.h>
3 #include <lib/dvb/epgcache.h>
4 #include <lib/dvb/metaparser.h>
5 #include <lib/base/httpstream.h>
6 #include <lib/base/nconfig.h>
12 #include <netinet/in.h>
15 #error no byte order defined!
18 DEFINE_REF(eDVBServiceRecord);
20 eDVBServiceRecord::eDVBServiceRecord(const eServiceReferenceDVB &ref, bool isstreamclient):
21 m_ref(ref),m_is_stream_client(isstreamclient)
23 CONNECT(m_service_handler.serviceEvent, eDVBServiceRecord::serviceEvent);
24 CONNECT(m_event_handler.m_eit_changed, eDVBServiceRecord::gotNewEvent);
29 m_pvr_descramble = false;
36 m_serviceType = eDVBServicePMTHandler::recording;
39 void eDVBServiceRecord::serviceEvent(int event)
41 eDebug("RECORD service event %d", event);
44 case eDVBServicePMTHandler::eventTuned:
49 /* start feeding EIT updates */
50 ePtr<iDVBDemux> m_demux;
51 if (!m_service_handler.getDataDemux(m_demux))
53 eServiceReferenceDVB &ref = (eServiceReferenceDVB&) m_ref;
54 int sid = ref.getParentServiceID().get();
56 sid = ref.getServiceID().get();
57 if ( ref.getParentTransportStreamID().get() &&
58 ref.getParentTransportStreamID() != ref.getTransportStreamID() )
59 m_event_handler.startOther(m_demux, sid);
61 m_event_handler.start(m_demux, sid);
64 if (m_state == stateRecording && m_want_record)
66 m_event((iRecordableService*)this, evTunedIn);
69 case eDVBServicePMTHandler::eventTuneFailed:
71 eDebug("record failed to tune");
72 m_event((iRecordableService*)this, evTuneFailed);
75 case eDVBServicePMTHandler::eventNewProgramInfo:
77 if (m_state == stateIdle)
79 else if (m_want_record) /* doRecord can be called from Prepared and Recording state */
86 m_event((iRecordableService*)this, evNewProgramInfo);
89 case eDVBServicePMTHandler::eventMisconfiguration:
90 m_error = errMisconfiguration;
91 m_event((iRecordableService*)this, evTuneFailed);
93 case eDVBServicePMTHandler::eventNoResources:
94 m_error = errNoResources;
95 m_event((iRecordableService*)this, evTuneFailed);
97 case eDVBServicePMTHandler::eventEOF:
98 m_event((iRecordableService*)this, evPvrEof);
100 case eDVBServicePMTHandler::eventStartPvrDescramble:
109 RESULT eDVBServiceRecord::prepare(const char *filename, time_t begTime, time_t endTime, int eit_event_id, const char *name, const char *descr, const char *tags, bool descramble, bool recordecm)
111 bool config_recording_always_ecm = ePythonConfigQuery::getConfigBoolValue("config.recording.always_ecm", false);
112 bool config_recording_never_decrypt = ePythonConfigQuery::getConfigBoolValue("config.recording.never_decrypt", false);
113 m_filename = filename;
115 m_descramble = config_recording_never_decrypt ? false : descramble;
116 m_record_ecm = config_recording_always_ecm ? true : recordecm;
118 // force descramble for _pvrdesc.ts
119 if (strstr(filename, "_pvrdesc.ts"))
121 m_pvr_descramble = true;
125 if (m_state == stateIdle)
127 int ret = doPrepare();
130 eServiceReferenceDVB ref = m_ref.getParentServiceReference();
131 ePtr<eDVBResourceManager> res_mgr;
133 std::string service_data;
136 if (!eDVBResourceManager::getInstance(res_mgr))
138 ePtr<iDVBChannelList> db;
139 if (!res_mgr->getChannelList(db))
141 ePtr<eDVBService> service;
142 if (!db->getService(ref, service))
145 sprintf(tmp, "f:%x", service->m_flags);
148 for (int x=0; x < eDVBService::cacheMax; ++x)
150 int entry = service->getCacheEntry((eDVBService::cacheID)x);
153 sprintf(tmp, ",c:%02d%04x", x, entry);
160 meta.m_time_create = begTime;
163 meta.m_service_data = service_data;
167 meta.m_description = descr;
170 meta.m_scrambled = !m_descramble;
171 ret = meta.updateMeta(m_filename) ? -255 : 0;
174 std::string fname = filename;
175 fname.erase(fname.length()-2, 2);
177 eEPGCache::getInstance()->saveEventToFile(fname.c_str(), ref, eit_event_id, begTime, endTime);
185 RESULT eDVBServiceRecord::prepareStreaming()
189 if (m_state == stateIdle)
194 RESULT eDVBServiceRecord::start(bool simulate)
196 m_simulate = simulate;
198 /* when tune wasn't yet successfully, doRecord stays in "prepared"-state which is fine. */
199 m_event((iRecordableService*)this, evStart);
203 RESULT eDVBServiceRecord::stop()
206 eDebug("stop recording!");
207 if (m_state == stateRecording)
211 if (m_target_fd >= 0)
213 ::close(m_target_fd);
219 m_state = statePrepared;
220 } else if (!m_simulate)
221 eDebug("(was not recording)");
222 if (m_state == statePrepared)
227 m_event((iRecordableService*)this, evRecordStopped);
231 int eDVBServiceRecord::doPrepare()
233 /* allocate a ts recorder if we don't already have one. */
234 if (m_state == stateIdle)
236 int use_decode_demux = 0;
240 m_serviceType = m_record_ecm ? eDVBServicePMTHandler::scrambled_streamserver : eDVBServicePMTHandler::streamserver;
244 m_serviceType = m_record_ecm ? eDVBServicePMTHandler::scrambled_recording : eDVBServicePMTHandler::recording;
247 m_pids_active.clear();
248 m_state = statePrepared;
249 ePtr<iTsSource> source;
250 if (!m_simulate && !m_ref.path.empty())
252 if (m_is_stream_client)
254 m_descramble = true; // assume stream is scrambled
255 m_record_ecm = false;
256 m_serviceType = eDVBServicePMTHandler::streamclient;
257 eHttpStream *f = new eHttpStream();
258 f->open(m_ref.path.c_str());
259 source = ePtr<iTsSource>(f);
263 use_decode_demux = 1;
265 /* re-record a recording */
267 if (!meta.parseFile(m_ref.path))
269 m_descramble = meta.m_scrambled;
274 m_serviceType = eDVBServicePMTHandler::pvrDescramble;
278 m_serviceType = eDVBServicePMTHandler::offline;
281 eRawFile *f = new eRawFile();
282 f->open(m_ref.path.c_str());
283 source = ePtr<iTsSource>(f);
285 m_event((iRecordableService*)this, evPvrTuneStart);
289 m_event((iRecordableService*)this, evTuneStart);
291 return m_service_handler.tuneExt(m_ref, use_decode_demux, source, m_ref.path.c_str(), 0, m_simulate, 0, m_serviceType, m_descramble);
296 int eDVBServiceRecord::doRecord()
298 int err = doPrepare();
301 m_error = errTuneFailed;
302 m_event((iRecordableService*)this, evRecordFailed);
307 return 0; /* try it again when we are tuned in */
309 if (!m_record && m_tuned && !m_streaming && !m_simulate)
311 if (m_pvr_descramble)
313 if (m_service_handler.isPmtReady())
315 if (!m_service_handler.isCiConnected())
317 m_event((iRecordableService*)this, evRecordFailed);
318 return errNoCiConnected;
327 eDebug("Recording to %s...", m_filename.c_str());
328 ::remove(m_filename.c_str());
329 int fd = ::open(m_filename.c_str(), O_WRONLY|O_CREAT|O_LARGEFILE, 0644);
332 eDebug("eDVBServiceRecord - can't open recording file!");
333 m_error = errOpenRecordFile;
334 m_event((iRecordableService*)this, evRecordFailed);
335 return errOpenRecordFile;
338 /* turn off kernel caching strategies */
339 posix_fadvise(fd, 0, 0, POSIX_FADV_RANDOM);
341 ePtr<iDVBDemux> demux;
342 if (m_service_handler.getDataDemux(demux))
344 eDebug("eDVBServiceRecord - NO DEMUX available!");
345 m_error = errNoDemuxAvailable;
346 m_event((iRecordableService*)this, evRecordFailed);
347 return errNoDemuxAvailable;
349 demux->createTSRecorder(m_record);
352 eDebug("eDVBServiceRecord - no ts recorder available.");
353 m_error = errNoTsRecorderAvailable;
354 m_event((iRecordableService*)this, evRecordFailed);
355 return errNoTsRecorderAvailable;
357 m_record->setTargetFD(fd);
358 m_record->setTargetFilename(m_filename.c_str());
359 m_record->connectEvent(slot(*this, &eDVBServiceRecord::recordEvent), m_con_record_event);
366 m_state = stateRecording;
367 eDebug("start streaming...");
370 eDebug("start recording...");
372 eDVBServicePMTHandler::program program;
373 if (m_service_handler.getProgramInfo(program))
374 eDebug("getting program info failed.");
377 std::set<int> pids_to_record;
379 pids_to_record.insert(0); // PAT
381 if (program.pmtPid != -1)
382 pids_to_record.insert(program.pmtPid); // PMT
384 int timing_pid = -1, timing_pid_type = -1;
386 eDebugNoNewLine("RECORD: have %zd video stream(s)", program.videoStreams.size());
387 if (!program.videoStreams.empty())
389 eDebugNoNewLine(" (");
390 for (std::vector<eDVBServicePMTHandler::videoStream>::const_iterator
391 i(program.videoStreams.begin());
392 i != program.videoStreams.end(); ++i)
394 pids_to_record.insert(i->pid);
396 if (timing_pid == -1)
399 timing_pid_type = i->type;
402 if (i != program.videoStreams.begin())
403 eDebugNoNewLine(", ");
404 eDebugNoNewLine("%04x", i->pid);
406 eDebugNoNewLine(")");
408 eDebugNoNewLine(", and %zd audio stream(s)", program.audioStreams.size());
409 if (!program.audioStreams.empty())
411 eDebugNoNewLine(" (");
412 for (std::vector<eDVBServicePMTHandler::audioStream>::const_iterator
413 i(program.audioStreams.begin());
414 i != program.audioStreams.end(); ++i)
416 pids_to_record.insert(i->pid);
418 if (timing_pid == -1)
421 timing_pid_type = -1;
424 if (i != program.audioStreams.begin())
425 eDebugNoNewLine(", ");
426 eDebugNoNewLine("%04x", i->pid);
428 eDebugNoNewLine(")");
430 if (!program.subtitleStreams.empty())
432 eDebugNoNewLine(" (");
433 for (std::vector<eDVBServicePMTHandler::subtitleStream>::const_iterator
434 i(program.subtitleStreams.begin());
435 i != program.subtitleStreams.end(); ++i)
437 pids_to_record.insert(i->pid);
439 if (i != program.subtitleStreams.begin())
440 eDebugNoNewLine(", ");
441 eDebugNoNewLine("%04x", i->pid);
443 eDebugNoNewLine(")");
445 eDebugNoNewLine(", and the pcr pid is %04x", program.pcrPid);
446 if (program.pcrPid != 0x1fff)
447 pids_to_record.insert(program.pcrPid);
448 eDebug(", and the text pid is %04x", program.textPid);
449 if (program.textPid != -1)
450 pids_to_record.insert(program.textPid); // Videotext
454 for (std::list<eDVBServicePMTHandler::program::capid_pair>::const_iterator i(program.caids.begin());
455 i != program.caids.end(); ++i)
457 if (i->capid >= 0) pids_to_record.insert(i->capid);
459 pids_to_record.insert(EventInformationSection::PID);
460 pids_to_record.insert(TimeAndDateSection::PID);
464 int isCrypted = (int)program.isCrypted();
465 int scrambled = !m_descramble;
468 scrambled = isCrypted;
474 else // m_descramble && isCrypted
476 if (!m_service_handler.isCiConnected())
481 eDVBMetaParser dvbParser;
482 dvbParser.parseFile(m_filename);
483 dvbParser.m_scrambled = scrambled;
484 dvbParser.updateMeta(m_filename);
487 /* find out which pids are NEW and which pids are obsolete.. */
488 std::set<int> new_pids, obsolete_pids;
490 std::set_difference(pids_to_record.begin(), pids_to_record.end(),
491 m_pids_active.begin(), m_pids_active.end(),
492 std::inserter(new_pids, new_pids.begin()));
495 m_pids_active.begin(), m_pids_active.end(),
496 pids_to_record.begin(), pids_to_record.end(),
497 std::inserter(obsolete_pids, obsolete_pids.begin())
500 for (std::set<int>::iterator i(new_pids.begin()); i != new_pids.end(); ++i)
502 eDebug("ADD PID: %04x", *i);
503 m_record->addPID(*i);
506 for (std::set<int>::iterator i(obsolete_pids.begin()); i != obsolete_pids.end(); ++i)
508 eDebug("REMOVED PID: %04x", *i);
509 m_record->removePID(*i);
512 if (timing_pid != -1)
513 m_record->setTimingPID(timing_pid, timing_pid_type);
515 m_pids_active = pids_to_record;
517 if (m_state != stateRecording)
520 m_state = stateRecording;
525 m_event((iRecordableService*)this, evRecordRunning);
529 void eDVBServiceRecord::updateDecoder()
531 int vpid = -1, vpidtype = -1, apid = -1, apidtype = -1, pcrpid = -1;
533 eDVBServicePMTHandler &h = m_service_handler;
535 eDVBServicePMTHandler::program program;
536 if (m_service_handler.getProgramInfo(program))
537 eDebug("getting program info failed.");
540 eDebugNoNewLine("have %zd video stream(s)", program.videoStreams.size());
541 if (!program.videoStreams.empty())
543 eDebugNoNewLine(" (");
544 for (std::vector<eDVBServicePMTHandler::videoStream>::const_iterator
545 i(program.videoStreams.begin());
546 i != program.videoStreams.end(); ++i)
553 if (i != program.videoStreams.begin())
554 eDebugNoNewLine(", ");
555 eDebugNoNewLine("%04x", i->pid);
557 eDebugNoNewLine(")");
560 eDebugNoNewLine(", and %zd audio stream(s)", program.audioStreams.size());
561 if (!program.audioStreams.empty())
563 eDebugNoNewLine(" (");
564 for (std::vector<eDVBServicePMTHandler::audioStream>::const_iterator
565 i(program.audioStreams.begin());
566 i != program.audioStreams.end(); ++i)
568 if (i != program.audioStreams.begin())
569 eDebugNoNewLine(", ");
570 eDebugNoNewLine("%04x", i->pid);
572 eDebugNoNewLine(")");
575 apid = program.audioStreams[program.defaultAudioStream].pid;
576 apidtype = program.audioStreams[program.defaultAudioStream].type;
578 eDebugNoNewLine(", and the pcr pid is %04x", program.pcrPid);
579 pcrpid = program.pcrPid;
584 h.getDecodeDemux(m_decode_demux);
587 m_decode_demux->getMPEGDecoder(m_decoder, 0);
593 m_decoder->setVideoPID(vpid, vpidtype);
594 m_decoder->setAudioPID(apid, apidtype);
595 m_decoder->setSyncPCR(-1);
600 RESULT eDVBServiceRecord::frontendInfo(ePtr<iFrontendInformation> &ptr)
606 RESULT eDVBServiceRecord::connectEvent(const Slot2<void,iRecordableService*,int> &event, ePtr<eConnection> &connection)
608 connection = new eConnection((iRecordableService*)this, m_event.connect(event));
612 RESULT eDVBServiceRecord::stream(ePtr<iStreamableService> &ptr)
618 extern void PutToDict(ePyObject &dict, const char*key, long val); // defined in dvb/frontend.cpp
620 PyObject *eDVBServiceRecord::getStreamingData()
622 eDVBServicePMTHandler::program program;
623 if (!m_tuned || m_service_handler.getProgramInfo(program))
628 ePyObject r = program.createPythonObject();
629 ePtr<iDVBDemux> demux;
630 if (!m_service_handler.getDataDemux(demux))
633 if (!demux->getCADemuxID(demux_id))
634 PutToDict(r, "demux", demux_id);
640 void eDVBServiceRecord::recordEvent(int event)
644 case iDVBTSRecorder::eventWriteError:
645 eWarning("[eDVBServiceRecord] record write error");
647 m_event((iRecordableService*)this, evRecordWriteError);
650 eDebug("unhandled record event %d", event);
654 void eDVBServiceRecord::gotNewEvent()
656 ePtr<eServiceEvent> event_now;
657 m_event_handler.getEvent(event_now, 0);
662 int event_id = event_now->getEventId();
668 if (m_record->getCurrentPCR(p))
669 eDebug("getting PCR failed!");
672 m_event_timestamps[event_id] = p;
673 eDebug("pcr of eit change: %llx", p);
677 if (event_id != m_last_event_id)
678 eDebug("[eDVBServiceRecord] now running: %s (%d seconds)", event_now->getEventName().c_str(), event_now->getDuration());
680 m_last_event_id = event_id;
682 m_event((iRecordableService*)this, evNewEventInfo);
685 void eDVBServiceRecord::saveCutlist()
687 /* XXX: dupe of eDVBServicePlay::saveCuesheet, refactor plz */
688 std::string filename = m_filename + ".cuts";
692 if (tstools.openFile(m_filename.c_str()))
694 eDebug("[eDVBServiceRecord] saving cutlist failed because tstools failed");
698 FILE *f = fopen(filename.c_str(), "wb");
702 unsigned long long where;
705 for (std::map<int,pts_t>::iterator i(m_event_timestamps.begin()); i != m_event_timestamps.end(); ++i)
708 off_t offset = 0; // fixme, we need to note down both
709 if (tstools.fixupPTS(offset, p))
711 eDebug("[eDVBServiceRecord] fixing up PTS failed, not saving");
714 eDebug("fixed up %llx to %llx (offset %llx)", i->second, p, offset);
715 #if BYTE_ORDER == BIG_ENDIAN
720 what = htonl(2); /* mark */
721 fwrite(&where, sizeof(where), 1, f);
722 fwrite(&what, sizeof(what), 1, f);
729 RESULT eDVBServiceRecord::subServices(ePtr<iSubserviceList> &ptr)
735 int eDVBServiceRecord::getNumberOfSubservices()
737 ePtr<eServiceEvent> evt;
738 if (!m_event_handler.getEvent(evt, 0))
739 return evt->getNumOfLinkageServices();
743 RESULT eDVBServiceRecord::getSubservice(eServiceReference &sub, unsigned int n)
745 ePtr<eServiceEvent> evt;
746 if (!m_event_handler.getEvent(evt, 0))
748 if (!evt->getLinkageService(sub, m_ref, n))
751 sub.type=eServiceReference::idInvalid;