enable http automatic redirects (requires very recent neonhttpsrc). (mpeg-1 podcasts...

[enigma2.git] / lib / service / servicedvbrecord.cpp

diff --git a/lib/service/servicedvbrecord.cpp b/lib/service/servicedvbrecord.cpp
index bded7cc9c757b602a86934b08434688e70c6802b..d3c3704bf707e2f694698b2908212699bec6f3d8 100644 (file)
--- a/lib/service/servicedvbrecord.cpp
+++ b/lib/service/servicedvbrecord.cpp
@@ -1,6 +1,6 @@
 #include <lib/service/servicedvbrecord.h>
 #include <lib/base/eerror.h>
-
+#include <lib/dvb/epgcache.h>
 #include <fcntl.h>
 
 DEFINE_REF(eDVBServiceRecord);
@@ -11,6 +11,8 @@ eDVBServiceRecord::eDVBServiceRecord(const eServiceReferenceDVB &ref): m_ref(ref
        m_state = stateIdle;
        m_want_record = 0;
        m_tuned = 0;
+       m_target_fd = -1;
+       m_error = 0;
 }
 
 void eDVBServiceRecord::serviceEvent(int event)
@@ -24,6 +26,13 @@ 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:
@@ -32,16 +41,63 @@ void eDVBServiceRecord::serviceEvent(int event)
                        doPrepare();
                else if (m_want_record) /* doRecord can be called from Prepared and Recording state */
                        doRecord();
+               m_event((iRecordableService*)this, evNewProgramInfo);
                break;
        }
        }
 }
 
-RESULT eDVBServiceRecord::prepare(const char *filename)
+RESULT eDVBServiceRecord::prepare(const char *filename, time_t begTime, time_t endTime, int eit_event_id)
 {
        m_filename = filename;
        if (m_state == stateIdle)
-               return doPrepare();
+       {
+               int ret = doPrepare();
+               if (!ret)
+               {
+                       eEPGCache::getInstance()->Lock();
+                       const eit_event_struct *event = 0;
+                       eServiceReferenceDVB ref = m_ref.getParentServiceReference();
+                       if (!ref.valid())
+                               ref = m_ref;
+                       if ( eit_event_id != -1 )
+                       {
+                               eDebug("query epg event id %d", eit_event_id);
+                               eEPGCache::getInstance()->lookupEventId(ref, eit_event_id, event);
+                       }
+                       if ( !event && (begTime != -1 && endTime != -1) )
+                       {
+                               time_t queryTime = begTime + ((endTime-begTime)/2);
+                               tm beg, end, query;
+                               localtime_r(&begTime, &beg);
+                               localtime_r(&endTime, &end);
+                               localtime_r(&queryTime, &query);
+                               eDebug("query stime %d:%d:%d, etime %d:%d:%d, qtime %d:%d:%d",
+                                       beg.tm_hour, beg.tm_min, beg.tm_sec,
+                                       end.tm_hour, end.tm_min, end.tm_sec,
+                                       query.tm_hour, query.tm_min, query.tm_sec);
+                               eEPGCache::getInstance()->lookupEventTime(ref, queryTime, event);
+                       }
+                       if ( event )
+                       {
+                               eDebug("found event.. store to disc");
+                               std::string fname = filename;
+                               fname.erase(fname.length()-2, 2);
+                               fname+="eit";
+                               int fd = open(fname.c_str(), O_CREAT|O_WRONLY, 0777);
+                               if (fd>-1)
+                               {
+                                       int evLen=HILO(event->descriptors_loop_length)+12/*EIT_LOOP_SIZE*/;
+                                       int wr = ::write( fd, (unsigned char*)event, evLen );
+                                       if ( wr != evLen )
+                                               eDebug("eit write error (%m)");
+                                       ::close(fd);
+                               }
+                       }
+                       eEPGCache::getInstance()->Unlock();
+               }
+               return ret;
+       }
        else
                return -1;
 }
@@ -50,6 +106,7 @@ RESULT eDVBServiceRecord::start()
 {
        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();
 }
 
@@ -57,10 +114,16 @@ RESULT eDVBServiceRecord::start()
 RESULT eDVBServiceRecord::stop()
 {
        eDebug("stop recording!!");
+       m_event((iRecordableService*)this, evStop);
        if (m_state == stateRecording)
        {
                if (m_record)
                        m_record->stop();
+               if (m_target_fd >= 0)
+               {
+                       ::close(m_target_fd);
+                       m_target_fd = -1;
+               }
                m_state = statePrepared;
        }
        
@@ -69,6 +132,7 @@ RESULT eDVBServiceRecord::stop()
                m_record = 0;
                m_state = stateIdle;
        }
+       m_event((iRecordableService*)this, evRecordStopped);
        return 0;
 }
 
@@ -89,21 +153,26 @@ int eDVBServiceRecord::doRecord()
 {
        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 */
@@ -113,16 +182,21 @@ int eDVBServiceRecord::doRecord()
                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_target_fd = fd;
        }
        eDebug("starting recording..");
        
@@ -178,6 +252,21 @@ int eDVBServiceRecord::doRecord()
                        }
                        eDebugNoNewLine(")");
                }
+               if (!program.subtitleStreams.empty())
+               {
+                       eDebugNoNewLine(" (");
+                       for (std::vector<eDVBServicePMTHandler::subtitleStream>::const_iterator
+                               i(program.subtitleStreams.begin());
+                               i != program.subtitleStreams.end(); ++i)
+                       {
+                               pids_to_record.insert(i->pid);
+
+                               if (i != program.subtitleStreams.begin())
+                                       eDebugNoNewLine(", ");
+                               eDebugNoNewLine("%04x", i->pid);
+                       }
+                       eDebugNoNewLine(")");
+               }
                eDebugNoNewLine(", and the pcr pid is %04x", program.pcrPid);
                if (program.pcrPid != 0x1fff)
                        pids_to_record.insert(program.pcrPid);
@@ -220,5 +309,19 @@ int eDVBServiceRecord::doRecord()
                        m_state = stateRecording;
                }
        }
+       m_error = 0;
+       m_event((iRecordableService*)this, evRecordRunning);
+       return 0;
+}
+
+RESULT eDVBServiceRecord::frontendInfo(ePtr<iFrontendInformation> &ptr)
+{
+       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;
 }