~iRecordableService();
#endif
public:
+ enum
+ {
+ evStart,
+ evStop,
+ evTunedIn,
+ evTuneFailed,
+ evRecordRunning,
+ evNewProgramInfo,
+ evRecordFailed
+// evDiskFull
+ };
+ enum
+ {
+ NoError=0,
+ errOpenRecordFile=-1,
+ errNoDemuxAvailable=-2,
+ errNoTsRecorderAvailable=-3,
+ errDiskFull=-4,
+ errTuneFailed=-255
+ };
+ virtual RESULT getError(int &)=0;
+ virtual RESULT connectEvent(const Slot2<void,iRecordableService*,int> &event, ePtr<eConnection> &connection)=0;
virtual RESULT prepare(const char *filename, time_t begTime=-1, time_t endTime=-1, int eit_event_id=-1)=0;
virtual RESULT start()=0;
virtual RESULT stop()=0;
m_want_record = 0;
m_tuned = 0;
m_target_fd = -1;
+ m_error = 0;
}
void eDVBServiceRecord::serviceEvent(int event)
m_tuned = 1;
if (m_state == stateRecording && m_want_record)
doRecord();
+ m_event((iRecordableService*)this, evTunedIn);
+ break;
+ }
+ case eDVBServicePMTHandler::eventTuneFailed:
+ {
+ eDebug("record failed to tune");
+ m_event((iRecordableService*)this, evTuneFailed);
break;
}
case eDVBServicePMTHandler::eventNewProgramInfo:
doPrepare();
else if (m_want_record) /* doRecord can be called from Prepared and Recording state */
doRecord();
+ m_event((iRecordableService*)this, evNewProgramInfo);
break;
}
}
{
m_want_record = 1;
/* when tune wasn't yet successfully, doRecord stays in "prepared"-state which is fine. */
+ m_event((iRecordableService*)this, evStart);
return doRecord();
}
m_record = 0;
m_state = stateIdle;
}
+ m_event((iRecordableService*)this, evStop);
return 0;
}
{
int err = doPrepare();
if (err)
+ {
+ m_error = errTuneFailed;
+ m_event((iRecordableService*)this, evRecordFailed);
return err;
+ }
if (!m_tuned)
return 0; /* try it again when we are tuned in */
if (!m_record && m_tuned)
{
-
eDebug("Recording to %s...", m_filename.c_str());
::remove(m_filename.c_str());
int fd = ::open(m_filename.c_str(), O_WRONLY|O_CREAT|O_LARGEFILE, 0644);
if (fd == -1)
{
eDebug("eDVBServiceRecord - can't open recording file!");
- return -1;
+ m_error = errOpenRecordFile;
+ m_event((iRecordableService*)this, evRecordFailed);
+ return errOpenRecordFile;
}
/* turn off kernel caching strategies */
if (m_service_handler.getDataDemux(demux))
{
eDebug("eDVBServiceRecord - NO DEMUX available!");
- return -2;
+ m_error = errNoDemuxAvailable;
+ m_event((iRecordableService*)this, evRecordFailed);
+ return errNoDemuxAvailable;
}
demux->createTSRecorder(m_record);
if (!m_record)
{
eDebug("eDVBServiceRecord - no ts recorder available.");
- return -3;
+ m_error = errNoTsRecorderAvailable;
+ m_event((iRecordableService*)this, evRecordFailed);
+ return errNoTsRecorderAvailable;
}
m_record->setTargetFD(fd);
m_record->setTargetFilename(m_filename.c_str());
m_state = stateRecording;
}
}
+ m_error = 0;
+ m_event((iRecordableService*)this, evRecordRunning);
return 0;
}
ptr = this;
return 0;
}
+
+RESULT eDVBServiceRecord::connectEvent(const Slot2<void,iRecordableService*,int> &event, ePtr<eConnection> &connection)
+{
+ connection = new eConnection((iRecordableService*)this, m_event.connect(event));
+ return 0;
+}
{
DECLARE_REF(eDVBServiceRecord);
public:
+ RESULT connectEvent(const Slot2<void,iRecordableService*,int> &event, ePtr<eConnection> &connection);
RESULT prepare(const char *filename, time_t begTime, time_t endTime, int eit_event_id);
RESULT start();
RESULT stop();
+ RESULT getError(int &error) { error = m_error; m_error = 0; return 0; }
private:
enum { stateIdle, statePrepared, stateRecording };
int m_state, m_want_record;
eDVBServiceRecord(const eServiceReferenceDVB &ref);
eServiceReferenceDVB m_ref;
- void serviceEvent(int event);
ePtr<iDVBTSRecorder> m_record;
- int m_recording, m_tuned;
+ int m_recording, m_tuned, m_error;
std::set<int> m_pids_active;
std::string m_filename;
int m_target_fd;
int doPrepare();
int doRecord();
RESULT frontendInfo(ePtr<iFrontendInformation> &ptr);
+
+ /* events */
+ void serviceEvent(int event);
+ Signal2<void,iRecordableService*,int> m_event;
+
};
#endif