1 #include <lib/service/servicedvbrecord.h>
2 #include <lib/base/eerror.h>
3 #include <lib/dvb/epgcache.h>
6 DEFINE_REF(eDVBServiceRecord);
8 eDVBServiceRecord::eDVBServiceRecord(const eServiceReferenceDVB &ref): m_ref(ref)
10 CONNECT(m_service_handler.serviceEvent, eDVBServiceRecord::serviceEvent);
19 void eDVBServiceRecord::serviceEvent(int event)
21 eDebug("RECORD service event %d", event);
24 case eDVBServicePMTHandler::eventTuned:
28 if (m_state == stateRecording && m_want_record)
30 m_event((iRecordableService*)this, evTunedIn);
33 case eDVBServicePMTHandler::eventTuneFailed:
35 eDebug("record failed to tune");
36 m_event((iRecordableService*)this, evTuneFailed);
39 case eDVBServicePMTHandler::eventNewProgramInfo:
41 if (m_state == stateIdle)
43 else if (m_want_record) /* doRecord can be called from Prepared and Recording state */
45 m_event((iRecordableService*)this, evNewProgramInfo);
51 RESULT eDVBServiceRecord::prepare(const char *filename, time_t begTime, time_t endTime, int eit_event_id)
53 m_filename = filename;
56 if (m_state == stateIdle)
58 int ret = doPrepare();
61 eEPGCache::getInstance()->Lock();
62 const eit_event_struct *event = 0;
63 eServiceReferenceDVB ref = m_ref.getParentServiceReference();
66 if ( eit_event_id != -1 )
68 eDebug("query epg event id %d", eit_event_id);
69 eEPGCache::getInstance()->lookupEventId(ref, eit_event_id, event);
71 if ( !event && (begTime != -1 && endTime != -1) )
73 time_t queryTime = begTime + ((endTime-begTime)/2);
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);
86 eDebug("found event.. store to disc");
87 std::string fname = filename;
88 fname.erase(fname.length()-2, 2);
90 int fd = open(fname.c_str(), O_CREAT|O_WRONLY, 0777);
93 int evLen=HILO(event->descriptors_loop_length)+12/*EIT_LOOP_SIZE*/;
94 int wr = ::write( fd, (unsigned char*)event, evLen );
96 eDebug("eit write error (%m)");
100 eEPGCache::getInstance()->Unlock();
108 RESULT eDVBServiceRecord::prepareStreaming()
112 if (m_state == stateIdle)
117 RESULT eDVBServiceRecord::start()
120 /* when tune wasn't yet successfully, doRecord stays in "prepared"-state which is fine. */
121 m_event((iRecordableService*)this, evStart);
126 RESULT eDVBServiceRecord::stop()
128 eDebug("stop recording!");
129 if (m_state == stateRecording)
133 if (m_target_fd >= 0)
135 ::close(m_target_fd);
138 m_state = statePrepared;
140 eDebug("(was not recording)");
141 if (m_state == statePrepared)
146 m_event((iRecordableService*)this, evRecordStopped);
151 int eDVBServiceRecord::doPrepare()
153 /* allocate a ts recorder if we don't already have one. */
154 if (m_state == stateIdle)
156 m_pids_active.clear();
157 m_state = statePrepared;
158 return m_service_handler.tune(m_ref, 0);
163 int eDVBServiceRecord::doRecord()
165 int err = doPrepare();
168 m_error = errTuneFailed;
169 m_event((iRecordableService*)this, evRecordFailed);
174 return 0; /* try it again when we are tuned in */
176 if (!m_record && m_tuned && !m_streaming)
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);
183 eDebug("eDVBServiceRecord - can't open recording file!");
184 m_error = errOpenRecordFile;
185 m_event((iRecordableService*)this, evRecordFailed);
186 return errOpenRecordFile;
189 /* turn off kernel caching strategies */
190 posix_fadvise(fd, 0, 0, POSIX_FADV_RANDOM);
192 ePtr<iDVBDemux> demux;
193 if (m_service_handler.getDataDemux(demux))
195 eDebug("eDVBServiceRecord - NO DEMUX available!");
196 m_error = errNoDemuxAvailable;
197 m_event((iRecordableService*)this, evRecordFailed);
198 return errNoDemuxAvailable;
200 demux->createTSRecorder(m_record);
203 eDebug("eDVBServiceRecord - no ts recorder available.");
204 m_error = errNoTsRecorderAvailable;
205 m_event((iRecordableService*)this, evRecordFailed);
206 return errNoTsRecorderAvailable;
208 m_record->setTargetFD(fd);
209 m_record->setTargetFilename(m_filename.c_str());
215 m_state = stateRecording;
216 eDebug("start streaming...");
219 eDebug("start recording...");
221 eDVBServicePMTHandler::program program;
222 if (m_service_handler.getProgramInfo(program))
223 eDebug("getting program info failed.");
226 std::set<int> pids_to_record;
228 pids_to_record.insert(0); // PAT
230 if (program.pmtPid != -1)
231 pids_to_record.insert(program.pmtPid); // PMT
235 eDebugNoNewLine("RECORD: have %d video stream(s)", program.videoStreams.size());
236 if (!program.videoStreams.empty())
238 eDebugNoNewLine(" (");
239 for (std::vector<eDVBServicePMTHandler::videoStream>::const_iterator
240 i(program.videoStreams.begin());
241 i != program.videoStreams.end(); ++i)
243 pids_to_record.insert(i->pid);
245 if (timing_pid == -1)
248 if (i != program.videoStreams.begin())
249 eDebugNoNewLine(", ");
250 eDebugNoNewLine("%04x", i->pid);
252 eDebugNoNewLine(")");
254 eDebugNoNewLine(", and %d audio stream(s)", program.audioStreams.size());
255 if (!program.audioStreams.empty())
257 eDebugNoNewLine(" (");
258 for (std::vector<eDVBServicePMTHandler::audioStream>::const_iterator
259 i(program.audioStreams.begin());
260 i != program.audioStreams.end(); ++i)
262 pids_to_record.insert(i->pid);
264 if (timing_pid == -1)
267 if (i != program.audioStreams.begin())
268 eDebugNoNewLine(", ");
269 eDebugNoNewLine("%04x", i->pid);
271 eDebugNoNewLine(")");
273 if (!program.subtitleStreams.empty())
275 eDebugNoNewLine(" (");
276 for (std::vector<eDVBServicePMTHandler::subtitleStream>::const_iterator
277 i(program.subtitleStreams.begin());
278 i != program.subtitleStreams.end(); ++i)
280 pids_to_record.insert(i->pid);
282 if (i != program.subtitleStreams.begin())
283 eDebugNoNewLine(", ");
284 eDebugNoNewLine("%04x", i->pid);
286 eDebugNoNewLine(")");
288 eDebugNoNewLine(", and the pcr pid is %04x", program.pcrPid);
289 if (program.pcrPid != 0x1fff)
290 pids_to_record.insert(program.pcrPid);
291 eDebug(", and the text pid is %04x", program.textPid);
292 if (program.textPid != -1)
293 pids_to_record.insert(program.textPid); // Videotext
295 /* find out which pids are NEW and which pids are obsolete.. */
296 std::set<int> new_pids, obsolete_pids;
298 std::set_difference(pids_to_record.begin(), pids_to_record.end(),
299 m_pids_active.begin(), m_pids_active.end(),
300 std::inserter(new_pids, new_pids.begin()));
303 m_pids_active.begin(), m_pids_active.end(),
304 pids_to_record.begin(), pids_to_record.end(),
305 std::inserter(new_pids, new_pids.begin())
308 for (std::set<int>::iterator i(new_pids.begin()); i != new_pids.end(); ++i)
310 eDebug("ADD PID: %04x", *i);
311 m_record->addPID(*i);
314 for (std::set<int>::iterator i(obsolete_pids.begin()); i != obsolete_pids.end(); ++i)
316 eDebug("REMOVED PID: %04x", *i);
317 m_record->removePID(*i);
320 if (timing_pid != -1)
321 m_record->setTimingPID(timing_pid);
323 m_pids_active = pids_to_record;
325 if (m_state != stateRecording)
328 m_state = stateRecording;
333 m_event((iRecordableService*)this, evRecordRunning);
337 RESULT eDVBServiceRecord::frontendInfo(ePtr<iFrontendInformation> &ptr)
343 RESULT eDVBServiceRecord::connectEvent(const Slot2<void,iRecordableService*,int> &event, ePtr<eConnection> &connection)
345 connection = new eConnection((iRecordableService*)this, m_event.connect(event));
349 RESULT eDVBServiceRecord::stream(ePtr<iStreamableService> &ptr)
355 PyObject *eDVBServiceRecord::getStreamingData()
357 eDVBServicePMTHandler::program program;
358 if (!m_tuned || m_service_handler.getProgramInfo(program))
364 PyObject *r = program.createPythonObject();
365 ePtr<iDVBDemux> demux;
366 if (!m_service_handler.getDataDemux(demux))
369 demux->getCADemuxID(demux_id);
371 PyDict_SetItemString(r, "demux", PyInt_FromLong(demux_id));