bool ODBCStatementImpl::hasNext()
{
if (hasData())
{
if (!extractions().size())
makeInternalExtractors();
if (!_prepared) doPrepare();
if (_stepCalled)
return _stepCalled = nextRowReady();
makeStep();
if (!nextRowReady())
{
if (hasMoreDataSets()) activateNextDataSet();
else return false;
if (SQL_NO_DATA == SQLMoreResults(_stmt))
return false;
addPreparation();
doPrepare();
fixupExtraction();
makeStep();
}
else if (Utility::isError(_nextResponse))
checkError(_nextResponse, "SQLFetch()");
return true;
}
return false;
}
void eDVBServiceRecord::serviceEvent(int event)
{
eDebug("RECORD service event %d", event);
switch (event)
{
case eDVBServicePMTHandler::eventTuned:
{
eDebug("tuned..");
m_tuned = 1;
/* start feeding EIT updates */
ePtr<iDVBDemux> m_demux;
if (!m_service_handler.getDataDemux(m_demux))
{
eServiceReferenceDVB &ref = (eServiceReferenceDVB&) m_ref;
int sid = ref.getParentServiceID().get();
if (!sid)
sid = ref.getServiceID().get();
if ( ref.getParentTransportStreamID().get() &&
ref.getParentTransportStreamID() != ref.getTransportStreamID() )
m_event_handler.startOther(m_demux, sid);
else
m_event_handler.start(m_demux, sid);
}
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:
{
if (m_state == stateIdle)
doPrepare();
else if (m_want_record) /* doRecord can be called from Prepared and Recording state */
doRecord();
m_event((iRecordableService*)this, evNewProgramInfo);
break;
}
case eDVBServicePMTHandler::eventMisconfiguration:
m_error = errMisconfiguration;
m_event((iRecordableService*)this, evTuneFailed);
break;
case eDVBServicePMTHandler::eventNoResources:
m_error = errNoResources;
m_event((iRecordableService*)this, evTuneFailed);
break;
case eDVBServicePMTHandler::eventStopped:
/* recording data source has stopped, stop recording */
stop();
m_event((iRecordableService*)this, evRecordAborted);
break;
}
}
RESULT eDVBServiceRecord::prepareStreaming()
{
m_filename = "";
m_streaming = 1;
if (m_state == stateIdle)
return doPrepare();
return -1;
}
int eDVBServiceStream::start(const char *serviceref, int fd)
{
if (m_state != stateIdle) return -1;
m_ref = eServiceReferenceDVB(serviceref);
if (doPrepare() < 0) return -1;
m_target_fd = fd;
m_want_record = 1;
return doRecord();
}
RESULT eDVBServiceRecord::prepareStreaming(bool descramble, bool includeecm)
{
m_filename = "";
m_streaming = 1;
m_descramble = descramble;
m_record_ecm = includeecm;
if (m_state == stateIdle)
return doPrepare();
return -1;
}
RESULT eServiceHDMIRecord::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)
{
m_filename = filename;
if (m_state == stateIdle)
{
return doPrepare();
}
return -1;
}
void eDVBServiceStream::serviceEvent(int event)
{
eDebug("STREAM service event %d", event);
switch (event)
{
case eDVBServicePMTHandler::eventTuned:
{
eDebug("tuned..");
m_tuned = 1;
/* start feeding EIT updates */
ePtr<iDVBDemux> m_demux;
if (!m_service_handler.getDataDemux(m_demux))
{
eServiceReferenceDVB &ref = (eServiceReferenceDVB&) m_ref;
int sid = ref.getParentServiceID().get();
if (!sid)
sid = ref.getServiceID().get();
if ( ref.getParentTransportStreamID().get() &&
ref.getParentTransportStreamID() != ref.getTransportStreamID() )
m_event_handler.startOther(m_demux, sid);
else
m_event_handler.start(m_demux, sid);
}
if (m_state == stateRecording && m_want_record)
doRecord();
break;
}
case eDVBServicePMTHandler::eventTuneFailed:
{
eDebug("stream failed to tune");
tuneFailed();
break;
}
case eDVBServicePMTHandler::eventNewProgramInfo:
{
if (m_state == stateIdle)
doPrepare();
else if (m_want_record) /* doRecord can be called from Prepared and Recording state */
doRecord();
break;
}
case eDVBServicePMTHandler::eventMisconfiguration:
tuneFailed();
break;
case eDVBServicePMTHandler::eventNoResources:
tuneFailed();
break;
}
}
void eDVBServiceStream::serviceEvent(int event)
{
eDebug("[eDVBServiceStream] STREAM service event %d", event);
if(event == eDVBServicePMTHandler::eventTuneFailed || event == eDVBServicePMTHandler::eventMisconfiguration || event == eDVBServicePMTHandler::eventNoResources)
eventUpdate(event);
switch (event)
{
case eDVBServicePMTHandler::eventTuned:
{
eDebug("[eDVBServiceStream] tuned.. m_state %d m_want_record %d", m_state, m_want_record);
m_tuned = 1;
/* start feeding EIT updates */
ePtr<iDVBDemux> m_demux;
if (!m_service_handler.getDataDemux(m_demux))
{
eServiceReferenceDVB &ref = (eServiceReferenceDVB&) m_ref;
m_event_handler.start(m_demux, ref);
}
if (m_state > stateIdle && m_want_record)
doRecord();
break;
}
case eDVBServicePMTHandler::eventTuneFailed:
{
eDebug("stream failed to tune");
tuneFailed();
break;
}
case eDVBServicePMTHandler::eventNewProgramInfo:
{
if (m_state == stateIdle)
doPrepare();
else if (m_want_record) /* doRecord can be called from Prepared and Recording state */
doRecord();
break;
}
case eDVBServicePMTHandler::eventMisconfiguration:
tuneFailed();
break;
case eDVBServicePMTHandler::eventNoResources:
tuneFailed();
break;
}
if(event != eDVBServicePMTHandler::eventTuneFailed && event != eDVBServicePMTHandler::eventMisconfiguration && event != eDVBServicePMTHandler::eventNoResources)
eventUpdate(event);
}
int eServiceHDMIRecord::doRecord()
{
int err = doPrepare();
if (err)
{
m_error = errTuneFailed;
m_event((iRecordableService*)this, evRecordFailed);
return err;
}
if (!m_thread && !m_simulate)
{
eDebug("[eServiceHDMIRecord] 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 | O_CLOEXEC, 0666);
if (fd < 0)
{
eDebug("[eServiceHDMIRecord] can't open recording file: %m");
m_error = errOpenRecordFile;
m_event((iRecordableService*)this, evRecordFailed);
return errOpenRecordFile;
}
m_thread = new eDVBRecordFileThread(188, 20);
m_thread->setTargetFD(fd);
m_target_fd = fd;
}
eDebug("[eServiceHDMIRecord] start recording...");
if (m_state != stateRecording)
{
if (m_thread && m_encoder_fd >= 0)
{
m_thread->startSaveMetaInformation(m_filename);
m_thread->start(m_encoder_fd);
}
m_state = stateRecording;
}
m_error = 0;
m_event((iRecordableService*)this, evRecordRunning);
return 0;
}
void ODBCStatementImpl::compileImpl()
{
if (!_canCompile) return;
_stepCalled = false;
_nextResponse = 0;
if (_preparations.size())
PreparationVec().swap(_preparations);
addPreparation();
Binder::ParameterBinding bind = session().getFeature("autoBind") ?
Binder::PB_IMMEDIATE : Binder::PB_AT_EXEC;
TypeInfo* pDT = 0;
try
{
Poco::Any dti = session().getProperty("dataTypeInfo");
pDT = AnyCast<TypeInfo*>(dti);
}catch (NotSupportedException&) { }
std::size_t maxFieldSize = AnyCast<std::size_t>(session().getProperty("maxFieldSize"));
_pBinder = new Binder(_stmt, maxFieldSize, bind, pDT);
// This is a hack to conform to some ODBC drivers behavior (e.g. MS SQLServer) with
// stored procedure calls: driver refuses to report the number of columns, unless all
// parameters for the stored procedure are bound. Since number of columns is essential
// information for the internal extraction creation, in order to allow for querying it,
// these calls must occur before.
fixupBinding(); doBind(false, true);
makeInternalExtractors();
doPrepare();
_canCompile = false;
}
RESULT eServiceMP3Record::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, int packetsize)
{
eDebug("[eMP3ServiceRecord] prepare filename %s", filename);
m_filename = filename;
if (m_state == stateIdle)
{
int ret = doPrepare();
if (!ret)
{
eDVBMetaParser meta;
std::string service_data;
meta.m_time_create = begTime;
meta.m_ref = eServiceReferenceDVB(m_ref.toString());
meta.m_data_ok = 1;
meta.m_service_data = service_data;
if (name)
meta.m_name = name;
if (descr)
meta.m_description = descr;
if (tags)
meta.m_tags = tags;
meta.m_scrambled = recordecm; /* assume we will record scrambled data, when ecm will be included in the recording */
ret = meta.updateMeta(m_filename.c_str()) ? -255 : 0;
if (!ret)
{
std::string fname = m_filename;
fname.erase(fname.length()-6, 6);
fname += "eit";
eEPGCache::getInstance()->saveEventToFile(fname.c_str(), m_ref, eit_event_id, begTime, endTime);
}
m_state = statePrepared;
}
return ret;
}
return -1;
}
int eServiceMP3Record::doRecord()
{
int err = doPrepare();
if (err)
{
m_error = errMisconfiguration;
m_event((iRecordableService*)this, evRecordFailed);
return err;
}
if (gst_element_set_state(m_recording_pipeline, GST_STATE_PLAYING) == GST_STATE_CHANGE_FAILURE)
{
eDebug("[eMP3ServiceRecord] doRecord error cannot set pipeline to state_playing");
m_error = errMisconfiguration;
m_event((iRecordableService*)this, evRecordFailed);
return -1;
}
m_state = stateRecording;
m_error = 0;
m_event((iRecordableService*)this, evRecordRunning);
return 0;
}
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)
{
m_filename = filename;
m_streaming = 0;
if (m_state == stateIdle)
{
int ret = doPrepare();
if (!ret)
{
eServiceReferenceDVB ref = m_ref.getParentServiceReference();
ePtr<eDVBResourceManager> res_mgr;
eDVBMetaParser meta;
std::string service_data;
if (!ref.valid())
ref = m_ref;
if (!eDVBResourceManager::getInstance(res_mgr))
{
ePtr<iDVBChannelList> db;
if (!res_mgr->getChannelList(db))
{
ePtr<eDVBService> service;
if (!db->getService(ref, service))
{
char tmp[255];
sprintf(tmp, "f:%x", service->m_flags);
service_data += tmp;
// cached pids
for (int x=0; x < eDVBService::cacheMax; ++x)
{
int entry = service->getCacheEntry((eDVBService::cacheID)x);
if (entry != -1)
{
sprintf(tmp, ",c:%02d%04x", x, entry);
service_data += tmp;
}
}
}
}
}
meta.m_time_create = begTime;
meta.m_ref = m_ref;
meta.m_data_ok = 1;
meta.m_service_data = service_data;
if (name)
meta.m_name = name;
if (descr)
meta.m_description = descr;
if (tags)
meta.m_tags = tags;
ret = meta.updateMeta(filename) ? -255 : 0;
if (!ret)
{
const eit_event_struct *event = 0;
eEPGCache::getInstance()->Lock();
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;
}
return -1;
}
int eDVBServiceStream::doRecord()
{
int err = doPrepare();
if (err)
{
return err;
}
if (!m_tuned)
return 0; /* try it again when we are tuned in */
if (!m_record && m_tuned)
{
ePtr<iDVBDemux> demux;
if (m_service_handler.getDataDemux(demux))
{
eDebug("eDVBServiceStream - NO DEMUX available");
return -1;
}
demux->createTSRecorder(m_record, /*packetsize*/ 188, /*streaming*/ true);
if (!m_record)
{
eDebug("eDVBServiceStream - no ts recorder available.");
return -1;
}
m_record->setTargetFD(m_target_fd);
m_record->connectEvent(slot(*this, &eDVBServiceStream::recordEvent), m_con_record_event);
}
eDebug("start streaming...");
eDVBServicePMTHandler::program program;
if (m_service_handler.getProgramInfo(program))
{
eDebug("getting program info failed.");
}
else
{
std::set<int> pids_to_record;
pids_to_record.insert(0); // PAT
if (program.pmtPid != -1)
pids_to_record.insert(program.pmtPid); // PMT
int timing_pid = -1, timing_stream_type = -1;
iDVBTSRecorder::timing_pid_type timing_pid_type = iDVBTSRecorder::none;
eDebugNoNewLine("STREAM: have %zd video stream(s)", program.videoStreams.size());
if (!program.videoStreams.empty())
{
eDebugNoNewLine(" (");
for (std::vector<eDVBServicePMTHandler::videoStream>::const_iterator
i(program.videoStreams.begin());
i != program.videoStreams.end(); ++i)
{
pids_to_record.insert(i->pid);
if (timing_pid == -1)
{
timing_pid = i->pid;
timing_stream_type = i->type;
timing_pid_type = iDVBTSRecorder::video_pid;
}
if (i != program.videoStreams.begin())
eDebugNoNewLine(", ");
eDebugNoNewLine("%04x", i->pid);
}
eDebugNoNewLine(")");
}
eDebugNoNewLine(", and %zd audio stream(s)", program.audioStreams.size());
if (!program.audioStreams.empty())
{
eDebugNoNewLine(" (");
for (std::vector<eDVBServicePMTHandler::audioStream>::const_iterator
i(program.audioStreams.begin());
i != program.audioStreams.end(); ++i)
{
pids_to_record.insert(i->pid);
if (timing_pid == -1)
{
timing_pid = i->pid;
timing_stream_type = i->type;
timing_pid_type = iDVBTSRecorder::audio_pid;
}
if (i != program.audioStreams.begin())
eDebugNoNewLine(", ");
eDebugNoNewLine("%04x", i->pid);
}
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 >= 0 && program.pcrPid < 0x1fff)
pids_to_record.insert(program.pcrPid);
eDebug(", and the text pid is %04x", program.textPid);
if (program.textPid != -1)
pids_to_record.insert(program.textPid); // Videotext
if (m_stream_ecm)
{
for (std::list<eDVBServicePMTHandler::program::capid_pair>::const_iterator i(program.caids.begin());
i != program.caids.end(); ++i)
{
if (i->capid >= 0) pids_to_record.insert(i->capid);
}
}
if (m_stream_ait)
{
if (program.aitPid >= 0) pids_to_record.insert(program.aitPid);
}
if (m_stream_eit)
{
pids_to_record.insert(0x12);
}
/* include TDT pid, really low bandwidth, should not hurt anyone */
pids_to_record.insert(0x14);
/* find out which pids are NEW and which pids are obsolete.. */
std::set<int> new_pids, obsolete_pids;
std::set_difference(pids_to_record.begin(), pids_to_record.end(),
m_pids_active.begin(), m_pids_active.end(),
std::inserter(new_pids, new_pids.begin()));
std::set_difference(
m_pids_active.begin(), m_pids_active.end(),
pids_to_record.begin(), pids_to_record.end(),
std::inserter(obsolete_pids, obsolete_pids.begin())
);
for (std::set<int>::iterator i(new_pids.begin()); i != new_pids.end(); ++i)
{
eDebug("ADD PID: %04x", *i);
m_record->addPID(*i);
}
for (std::set<int>::iterator i(obsolete_pids.begin()); i != obsolete_pids.end(); ++i)
{
eDebug("REMOVED PID: %04x", *i);
m_record->removePID(*i);
}
if (timing_pid != -1)
m_record->setTimingPID(timing_pid, timing_pid_type, timing_stream_type);
m_pids_active = pids_to_record;
if (m_state != stateRecording)
{
m_record->start();
m_state = stateRecording;
}
}
return 0;
}
int eDVBServiceStream::doRecord()
{
int err = doPrepare();
if (err)
{
eDebug("[eDVBServiceStream] doPrerare err %d", err);
return err;
}
if (!m_tuned)
{
eDebug("[eDVBServiceStream] try it again when we are tuned in");
return 0; /* try it again when we are tuned in */
}
if (!m_record && m_tuned)
{
ePtr<iDVBDemux> demux;
if (m_service_handler.getDataDemux(demux))
{
eDebug("[eDVBServiceStream] NO DEMUX available");
return -1;
}
demux->createTSRecorder(m_record, /*packetsize*/ 188, /*streaming*/ true);
if (!m_record)
{
eDebug("[eDVBServiceStream] no ts recorder available.");
return -1;
}
m_record->setTargetFD(m_target_fd);
m_record->connectEvent(slot(*this, &eDVBServiceStream::recordEvent), m_con_record_event);
}
eDebug("[eDVBServiceStream] start streaming...");
if (recordCachedPids())
{
eDebug("[eDVBServiceStream] streaming pids from cache.");
return 0;
}
eDVBServicePMTHandler::program program;
if (m_service_handler.getProgramInfo(program))
{
eDebug("[eDVBServiceStream] getting program info failed.");
}
else
{
std::set<int> pids_to_record;
pids_to_record.insert(0); // PAT
if (program.pmtPid != -1)
pids_to_record.insert(program.pmtPid); // PMT
int timing_pid = -1, timing_stream_type = -1;
iDVBTSRecorder::timing_pid_type timing_pid_type = iDVBTSRecorder::none;
eDebugNoNewLineStart("[eDVBServiceStream] have %zd video stream(s)", program.videoStreams.size());
if (!program.videoStreams.empty())
{
eDebugNoNewLine(" (");
for (std::vector<eDVBServicePMTHandler::videoStream>::const_iterator
i(program.videoStreams.begin());
i != program.videoStreams.end(); ++i)
{
pids_to_record.insert(i->pid);
if (timing_pid == -1)
{
timing_pid = i->pid;
timing_stream_type = i->type;
timing_pid_type = iDVBTSRecorder::video_pid;
}
if (i != program.videoStreams.begin())
eDebugNoNewLine(", ");
eDebugNoNewLine("%04x", i->pid);
}
eDebugNoNewLine(")");
}
eDebugNoNewLine(", and %zd audio stream(s)", program.audioStreams.size());
if (!program.audioStreams.empty())
{
eDebugNoNewLine(" (");
for (std::vector<eDVBServicePMTHandler::audioStream>::const_iterator
i(program.audioStreams.begin());
i != program.audioStreams.end(); ++i)
{
pids_to_record.insert(i->pid);
if (timing_pid == -1)
{
timing_pid = i->pid;
timing_stream_type = i->type;
timing_pid_type = iDVBTSRecorder::audio_pid;
}
if (i != program.audioStreams.begin())
eDebugNoNewLine(", ");
eDebugNoNewLine("%04x", i->pid);
}
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 >= 0 && program.pcrPid < 0x1fff)
pids_to_record.insert(program.pcrPid);
eDebugNoNewLine(", and the text pid is %04x\n", program.textPid);
if (program.textPid != -1)
pids_to_record.insert(program.textPid); // Videotext
if (m_stream_ecm)
{
for (std::list<eDVBServicePMTHandler::program::capid_pair>::const_iterator i(program.caids.begin());
i != program.caids.end(); ++i)
{
if (i->capid >= 0) pids_to_record.insert(i->capid);
}
}
if (m_stream_ait)
{
if (program.aitPid >= 0) pids_to_record.insert(program.aitPid);
}
if (m_stream_eit)
{
pids_to_record.insert(0x12);
}
/* include TDT pid, really low bandwidth, should not hurt anyone */
pids_to_record.insert(0x14);
recordPids(pids_to_record, timing_pid, timing_stream_type, timing_pid_type);
}
return 0;
}
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, int packetsize)
{
bool config_recording_always_ecm = eConfigManager::getConfigBoolValue("config.recording.always_ecm", false);
bool config_recording_never_decrypt = eConfigManager::getConfigBoolValue("config.recording.never_decrypt", false);
m_filename = filename;
m_streaming = 0;
m_descramble = config_recording_never_decrypt ? false : descramble;
m_record_ecm = config_recording_always_ecm ? true : recordecm;
m_packet_size = packetsize;
if (m_state == stateIdle)
{
int ret = doPrepare();
if (!ret)
{
eServiceReferenceDVB ref = m_ref.getParentServiceReference();
ePtr<eDVBService> service;
eDVBMetaParser meta;
std::string service_data;
if (!ref.valid())
ref = m_ref;
if (!eDVBDB::getInstance()->getService(ref, service))
{
char tmp[255];
sprintf(tmp, "f:%x", service->m_flags);
service_data += tmp;
// cached pids
for (int x=0; x < eDVBService::cacheMax; ++x)
{
int entry = service->getCacheEntry((eDVBService::cacheID)x);
if (entry != -1)
{
sprintf(tmp, ",c:%02d%04x", x, entry);
service_data += tmp;
}
}
}
meta.m_time_create = begTime;
meta.m_ref = m_ref;
meta.m_data_ok = 1;
meta.m_service_data = service_data;
if (name)
meta.m_name = name;
if (descr)
meta.m_description = descr;
if (tags)
meta.m_tags = tags;
meta.m_scrambled = !m_descramble;
meta.m_packet_size = m_packet_size;
ret = meta.updateMeta(filename) ? -255 : 0;
if (!ret)
{
std::string fname = filename;
fname.erase(fname.length()-2, 2);
fname += "eit";
eEPGCache::getInstance()->saveEventToFile(fname.c_str(), ref, eit_event_id, begTime, endTime);
}
}
return ret;
}
return -1;
}
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 && !m_streaming && !m_simulate)
{
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, 0666);
if (fd == -1)
{
eDebug("eDVBServiceRecord - can't open recording file!");
m_error = errOpenRecordFile;
m_event((iRecordableService*)this, evRecordFailed);
return errOpenRecordFile;
}
ePtr<iDVBDemux> demux;
if (m_service_handler.getDataDemux(demux))
{
eDebug("eDVBServiceRecord - NO DEMUX available!");
m_error = errNoDemuxAvailable;
m_event((iRecordableService*)this, evRecordFailed);
return errNoDemuxAvailable;
}
demux->createTSRecorder(m_record);
if (!m_record)
{
eDebug("eDVBServiceRecord - no ts recorder available.");
m_error = errNoTsRecorderAvailable;
m_event((iRecordableService*)this, evRecordFailed);
return errNoTsRecorderAvailable;
}
m_record->setTargetFD(fd);
m_record->setTargetFilename(m_filename);
m_record->connectEvent(slot(*this, &eDVBServiceRecord::recordEvent), m_con_record_event);
m_target_fd = fd;
}
if (m_streaming)
{
m_state = stateRecording;
eDebug("start streaming...");
} else
{
eDebug("start recording...");
eDVBServicePMTHandler::program program;
if (m_service_handler.getProgramInfo(program))
eDebug("getting program info failed.");
else
{
std::set<int> pids_to_record;
pids_to_record.insert(0); // PAT
if (program.pmtPid != -1)
pids_to_record.insert(program.pmtPid); // PMT
int timing_pid = -1, timing_stream_type = -1;
iDVBTSRecorder::timing_pid_type timing_pid_type = iDVBTSRecorder::none;
eDebugNoNewLine("RECORD: have %zd video stream(s)", program.videoStreams.size());
if (!program.videoStreams.empty())
{
eDebugNoNewLine(" (");
for (std::vector<eDVBServicePMTHandler::videoStream>::const_iterator
i(program.videoStreams.begin());
i != program.videoStreams.end(); ++i)
{
pids_to_record.insert(i->pid);
if (timing_pid == -1)
{
timing_pid = i->pid;
timing_stream_type = i->type;
timing_pid_type = iDVBTSRecorder::video_pid;
}
if (i != program.videoStreams.begin())
eDebugNoNewLine(", ");
eDebugNoNewLine("%04x", i->pid);
}
eDebugNoNewLine(")");
}
eDebugNoNewLine(", and %zd audio stream(s)", program.audioStreams.size());
if (!program.audioStreams.empty())
{
eDebugNoNewLine(" (");
for (std::vector<eDVBServicePMTHandler::audioStream>::const_iterator
i(program.audioStreams.begin());
i != program.audioStreams.end(); ++i)
{
pids_to_record.insert(i->pid);
if (timing_pid == -1)
{
timing_pid = i->pid;
timing_stream_type = i->type;
timing_pid_type = iDVBTSRecorder::audio_pid;
}
if (i != program.audioStreams.begin())
eDebugNoNewLine(", ");
eDebugNoNewLine("%04x", i->pid);
}
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 >= 0 && program.pcrPid < 0x1fff)
pids_to_record.insert(program.pcrPid);
eDebug(", and the text pid is %04x", program.textPid);
if (program.textPid != -1)
pids_to_record.insert(program.textPid); // Videotext
if (m_record_ecm)
{
for (std::list<eDVBServicePMTHandler::program::capid_pair>::const_iterator i(program.caids.begin());
i != program.caids.end(); ++i)
{
if (i->capid >= 0) pids_to_record.insert(i->capid);
}
}
/* find out which pids are NEW and which pids are obsolete.. */
std::set<int> new_pids, obsolete_pids;
std::set_difference(pids_to_record.begin(), pids_to_record.end(),
m_pids_active.begin(), m_pids_active.end(),
std::inserter(new_pids, new_pids.begin()));
std::set_difference(
m_pids_active.begin(), m_pids_active.end(),
pids_to_record.begin(), pids_to_record.end(),
std::inserter(obsolete_pids, obsolete_pids.begin())
);
for (std::set<int>::iterator i(new_pids.begin()); i != new_pids.end(); ++i)
{
eDebug("ADD PID: %04x", *i);
m_record->addPID(*i);
}
for (std::set<int>::iterator i(obsolete_pids.begin()); i != obsolete_pids.end(); ++i)
{
eDebug("REMOVED PID: %04x", *i);
m_record->removePID(*i);
}
if (timing_pid != -1)
m_record->setTimingPID(timing_pid, timing_pid_type, timing_stream_type);
m_pids_active = pids_to_record;
if (m_state != stateRecording)
{
m_record->start();
m_state = stateRecording;
}
}
}
m_error = 0;
m_event((iRecordableService*)this, evRecordRunning);
return 0;
}
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)
{
m_filename = filename;
m_streaming = 0;
m_descramble = descramble;
m_record_ecm = recordecm;
if (m_state == stateIdle)
{
int ret = doPrepare();
if (!ret)
{
eServiceReferenceDVB ref = m_ref.getParentServiceReference();
ePtr<eDVBResourceManager> res_mgr;
eDVBMetaParser meta;
std::string service_data;
if (!ref.valid())
ref = m_ref;
if (!eDVBResourceManager::getInstance(res_mgr))
{
ePtr<iDVBChannelList> db;
if (!res_mgr->getChannelList(db))
{
ePtr<eDVBService> service;
if (!db->getService(ref, service))
{
char tmp[255];
sprintf(tmp, "f:%x", service->m_flags);
service_data += tmp;
// cached pids
for (int x=0; x < eDVBService::cacheMax; ++x)
{
int entry = service->getCacheEntry((eDVBService::cacheID)x);
if (entry != -1)
{
sprintf(tmp, ",c:%02d%04x", x, entry);
service_data += tmp;
}
}
}
}
}
meta.m_time_create = begTime;
meta.m_ref = m_ref;
meta.m_data_ok = 1;
meta.m_service_data = service_data;
if (name)
meta.m_name = name;
if (descr)
meta.m_description = descr;
if (tags)
meta.m_tags = tags;
meta.m_scrambled = m_record_ecm; /* assume we will record scrambled data, when ecm will be included in the recording */
ret = meta.updateMeta(filename) ? -255 : 0;
if (!ret)
{
std::string fname = filename;
fname.erase(fname.length()-2, 2);
fname += "eit";
eEPGCache::getInstance()->saveEventToFile(fname.c_str(), ref, eit_event_id, begTime, endTime);
}
}
return ret;
}
return -1;
}
int eDVBServiceStream::doRecord()
{
int err = doPrepare();
if (err)
{
eDebug("[eDVBServiceStream] doPrerare err %d", err);
return err;
}
if (!m_tuned)
{
eDebug("[eDVBServiceStream] try it again when we are tuned in");
return 0; /* try it again when we are tuned in */
}
if (!m_record && m_tuned)
{
ePtr<iDVBDemux> demux;
if (m_service_handler.getDataDemux(demux))
{
eDebug("eDVBServiceStream - NO DEMUX available");
return -1;
}
demux->createTSRecorder(m_record, /*packetsize*/ 188, /*streaming*/ true);
if (!m_record)
{
eDebug("eDVBServiceStream - no ts recorder available.");
return -1;
}
m_record->setTargetFD(m_target_fd);
m_record->connectEvent(sigc::mem_fun(*this, &eDVBServiceStream::recordEvent), m_con_record_event);
}
eDebug("start streaming...");
if (recordCachedPids())
{
eDebug("[eDVBServiceStream] streaming pids from cache.");
return 0;
}
eDVBServicePMTHandler::program program;
if (m_service_handler.getProgramInfo(program))
{
eDebug("getting program info failed.");
}
else
{
std::set<int> pids_to_record;
eServiceReferenceDVB ref = m_ref.getParentServiceReference();
ePtr<eDVBService> service;
if (!ref.valid())
ref = m_ref;
if(!eDVBDB::getInstance()->getService(ref, service))
{
// cached pids
for (int x = 0; x < eDVBService::cacheMax; ++x)
{
if (x == 5)
{
x += 3; // ignore cVTYPE, cACHANNEL, cAC3DELAY, cPCMDELAY
continue;
}
int entry = service->getCacheEntry((eDVBService::cacheID)x);
if (entry != -1)
{
if (eDVBService::cSUBTITLE == (eDVBService::cacheID)x)
{
entry = (entry&0xFFFF0000)>>16;
}
pids_to_record.insert(entry);
}
}
}
pids_to_record.insert(0); // PAT
if (program.pmtPid != -1)
pids_to_record.insert(program.pmtPid); // PMT
int timing_pid = -1, timing_stream_type = -1;
iDVBTSRecorder::timing_pid_type timing_pid_type = iDVBTSRecorder::none;
eDebugNoNewLineStart("STREAM: have %zd video stream(s)", program.videoStreams.size());
if (!program.videoStreams.empty())
{
eDebugNoNewLine(" (");
for (std::vector<eDVBServicePMTHandler::videoStream>::const_iterator
i(program.videoStreams.begin());
i != program.videoStreams.end(); ++i)
{
pids_to_record.insert(i->pid);
if (timing_pid == -1)
{
timing_pid = i->pid;
timing_stream_type = i->type;
timing_pid_type = iDVBTSRecorder::video_pid;
}
if (i != program.videoStreams.begin())
eDebugNoNewLine(", ");
eDebugNoNewLine("%04x", i->pid);
}
eDebugNoNewLine(")");
}
eDebugNoNewLine(", and %zd audio stream(s)", program.audioStreams.size());
if (!program.audioStreams.empty())
{
eDebugNoNewLine(" (");
for (std::vector<eDVBServicePMTHandler::audioStream>::const_iterator
i(program.audioStreams.begin());
i != program.audioStreams.end(); ++i)
{
pids_to_record.insert(i->pid);
if (timing_pid == -1)
{
timing_pid = i->pid;
timing_stream_type = i->type;
timing_pid_type = iDVBTSRecorder::audio_pid;
}
if (i != program.audioStreams.begin())
eDebugNoNewLine(", ");
eDebugNoNewLine("%04x", i->pid);
}
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 >= 0 && program.pcrPid < 0x1fff)
pids_to_record.insert(program.pcrPid);
eDebugNoNewLineEnd(", and the text pid is %04x", program.textPid);
if (program.textPid != -1)
pids_to_record.insert(program.textPid); // Videotext
if (m_stream_ecm)
{
for (std::list<eDVBServicePMTHandler::program::capid_pair>::const_iterator i(program.caids.begin());
i != program.caids.end(); ++i)
{
if (i->capid >= 0) pids_to_record.insert(i->capid);
}
}
if (m_stream_ait)
{
if (program.aitPid >= 0) pids_to_record.insert(program.aitPid);
}
if (m_stream_eit)
{
pids_to_record.insert(0x12);
}
/* include TDT pid, really low bandwidth, should not hurt anyone */
pids_to_record.insert(0x14);
recordPids(pids_to_record, timing_pid, timing_stream_type, timing_pid_type);
}
int eDVBServiceStream::doRecord()
{
int err = doPrepare();
if (err)
{
eDebug("[eDVBServiceStream] doPrerare err %d", err);
return err;
}
if (!m_tuned)
{
eDebug("[eDVBServiceStream] try it again when we are tuned in");
return 0; /* try it again when we are tuned in */
}
if (!m_record && m_tuned)
{
ePtr<iDVBDemux> demux;
if (m_service_handler.getDataDemux(demux))
{
eDebug("eDVBServiceStream - NO DEMUX available");
return -1;
}
demux->createTSRecorder(m_record, /*packetsize*/ 188, /*streaming*/ true);
if (!m_record)
{
eDebug("eDVBServiceStream - no ts recorder available.");
return -1;
}
m_record->setTargetFD(m_target_fd);
m_record->connectEvent(sigc::mem_fun(*this, &eDVBServiceStream::recordEvent), m_con_record_event);
}
eDebug("start streaming...");
if (recordCachedPids())
{
eDebug("[eDVBServiceStream] streaming pids from cache.");
return 0;
}
eDVBServicePMTHandler::program program;
if (m_service_handler.getProgramInfo(program))
{
eDebug("getting program info failed.");
}
else if(m_record_no_pids == 0)
{
std::set<int> pids_to_record;
eServiceReferenceDVB ref = m_ref.getParentServiceReference();
ePtr<eDVBService> service;
if (!ref.valid())
ref = m_ref;
if(!eDVBDB::getInstance()->getService(ref, service))
{
// cached pids
for (int x = 0; x < eDVBService::cacheMax; ++x)
{
if (x == 5)
{
x += 3; // ignore cVTYPE, cACHANNEL, cAC3DELAY, cPCMDELAY
continue;
}
int entry = service->getCacheEntry((eDVBService::cacheID)x);
if (entry != -1)
{
if (eDVBService::cSUBTITLE == (eDVBService::cacheID)x)
{
entry = (entry&0xFFFF0000)>>16;
}
pids_to_record.insert(entry);
}
}
}
void EntityModel::prepare(const int minFilter, const int magFilter) {
if (!m_prepared) {
doPrepare(minFilter, magFilter);
m_prepared = true;
}
}
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 && !m_streaming && !m_simulate)
{
#if defined(__sh__)
int flags = O_WRONLY|O_CREAT|O_LARGEFILE;
struct statfs sbuf;
#endif
eDebug("Recording to %s...", m_filename.c_str());
::remove(m_filename.c_str());
#if defined(__sh__)
//nit2005, we must creat a file for statfs
int fd = ::open(m_filename.c_str(), O_WRONLY|O_CREAT|O_LARGEFILE, 0644);
::close(fd);
if (statfs(m_filename.c_str(), &sbuf) < 0)
{
eDebug("eDVBServiceRecord - can't get fs type assuming none NFS!");
} else
{
if (sbuf.f_type == EXT3_SUPER_MAGIC)
eDebug("eDVBServiceRecord - Ext2/3/4 Filesystem\n");
else
if (sbuf.f_type == NFS_SUPER_MAGIC)
{
eDebug("eDVBServiceRecord - NFS Filesystem; add O_DIRECT to flags\n");
flags |= O_DIRECT;
}
else
if (sbuf.f_type == USBDEVICE_SUPER_MAGIC)
eDebug("eDVBServiceRecord - USB Device\n");
else
if (sbuf.f_type == SMB_SUPER_MAGIC)
eDebug("eDVBServiceRecord - SMBs Device\n");
else
if (sbuf.f_type == MSDOS_SUPER_MAGIC)
eDebug("eDVBServiceRecord - MSDOS Device\n");
}
fd = ::open(m_filename.c_str(), flags, 0644);
#else
int fd = ::open(m_filename.c_str(), O_WRONLY|O_CREAT|O_LARGEFILE, 0644);
#endif
if (fd == -1)
{
eDebug("eDVBServiceRecord - can't open recording file!");
m_error = errOpenRecordFile;
m_event((iRecordableService*)this, evRecordFailed);
return errOpenRecordFile;
}
/* turn off kernel caching strategies */
posix_fadvise(fd, 0, 0, POSIX_FADV_RANDOM);
ePtr<iDVBDemux> demux;
if (m_service_handler.getDataDemux(demux))
{
eDebug("eDVBServiceRecord - NO DEMUX available!");
m_error = errNoDemuxAvailable;
m_event((iRecordableService*)this, evRecordFailed);
return errNoDemuxAvailable;
}
demux->createTSRecorder(m_record);
if (!m_record)
{
eDebug("eDVBServiceRecord - no ts recorder available.");
m_error = errNoTsRecorderAvailable;
m_event((iRecordableService*)this, evRecordFailed);
return errNoTsRecorderAvailable;
}
m_record->setTargetFD(fd);
m_record->setTargetFilename(m_filename.c_str());
m_record->connectEvent(slot(*this, &eDVBServiceRecord::recordEvent), m_con_record_event);
m_target_fd = fd;
}
if (m_streaming)
{
m_state = stateRecording;
eDebug("start streaming...");
} else
{
eDebug("start recording...");
eDVBServicePMTHandler::program program;
if (m_service_handler.getProgramInfo(program))
eDebug("getting program info failed.");
else
{
std::set<int> pids_to_record;
pids_to_record.insert(0); // PAT
if (program.pmtPid != -1)
pids_to_record.insert(program.pmtPid); // PMT
int timing_pid = -1, timing_pid_type = -1;
eDebugNoNewLine("RECORD: have %d video stream(s)", program.videoStreams.size());
if (!program.videoStreams.empty())
{
eDebugNoNewLine(" (");
for (std::vector<eDVBServicePMTHandler::videoStream>::const_iterator
i(program.videoStreams.begin());
i != program.videoStreams.end(); ++i)
{
pids_to_record.insert(i->pid);
if (timing_pid == -1)
{
timing_pid = i->pid;
timing_pid_type = i->type;
}
if (i != program.videoStreams.begin())
eDebugNoNewLine(", ");
eDebugNoNewLine("%04x", i->pid);
}
eDebugNoNewLine(")");
}
eDebugNoNewLine(", and %d audio stream(s)", program.audioStreams.size());
if (!program.audioStreams.empty())
{
eDebugNoNewLine(" (");
for (std::vector<eDVBServicePMTHandler::audioStream>::const_iterator
i(program.audioStreams.begin());
i != program.audioStreams.end(); ++i)
{
pids_to_record.insert(i->pid);
if (timing_pid == -1)
{
timing_pid = i->pid;
timing_pid_type = -1;
}
if (i != program.audioStreams.begin())
eDebugNoNewLine(", ");
eDebugNoNewLine("%04x", i->pid);
}
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);
eDebug(", and the text pid is %04x", program.textPid);
if (program.textPid != -1)
pids_to_record.insert(program.textPid); // Videotext
/* find out which pids are NEW and which pids are obsolete.. */
std::set<int> new_pids, obsolete_pids;
std::set_difference(pids_to_record.begin(), pids_to_record.end(),
m_pids_active.begin(), m_pids_active.end(),
std::inserter(new_pids, new_pids.begin()));
std::set_difference(
m_pids_active.begin(), m_pids_active.end(),
pids_to_record.begin(), pids_to_record.end(),
std::inserter(obsolete_pids, obsolete_pids.begin())
);
for (std::set<int>::iterator i(new_pids.begin()); i != new_pids.end(); ++i)
{
eDebug("ADD PID: %04x", *i);
m_record->addPID(*i);
}
for (std::set<int>::iterator i(obsolete_pids.begin()); i != obsolete_pids.end(); ++i)
{
eDebug("REMOVED PID: %04x", *i);
m_record->removePID(*i);
}
if (timing_pid != -1)
m_record->setTimingPID(timing_pid, timing_pid_type);
m_pids_active = pids_to_record;
if (m_state != stateRecording)
{
m_record->start();
m_state = stateRecording;
}
}
}
m_error = 0;
m_event((iRecordableService*)this, evRecordRunning);
return 0;
}
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 && !m_streaming && !m_simulate)
{
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 | O_CLOEXEC, 0666);
if (fd == -1)
{
eDebug("eDVBServiceRecord - can't open recording file!");
m_error = errOpenRecordFile;
m_event((iRecordableService*)this, evRecordFailed);
return errOpenRecordFile;
}
ePtr<iDVBDemux> demux;
if (m_service_handler.getDataDemux(demux))
{
eDebug("eDVBServiceRecord - NO DEMUX available!");
m_error = errNoDemuxAvailable;
m_event((iRecordableService*)this, evRecordFailed);
return errNoDemuxAvailable;
}
demux->createTSRecorder(m_record);
if (!m_record)
{
eDebug("eDVBServiceRecord - no ts recorder available.");
m_error = errNoTsRecorderAvailable;
m_event((iRecordableService*)this, evRecordFailed);
return errNoTsRecorderAvailable;
}
m_record->setTargetFD(fd);
m_record->setTargetFilename(m_filename);
m_record->connectEvent(slot(*this, &eDVBServiceRecord::recordEvent), m_con_record_event);
m_target_fd = fd;
}
if (m_streaming)
{
m_state = stateRecording;
eDebug("start streaming...");
} else
{
eDebugNoNewLineStart("start recording...");
eDVBServicePMTHandler::program program;
if (m_service_handler.getProgramInfo(program))
eDebug("getting program info failed.");
else
{
std::set<int> pids_to_record;
eServiceReferenceDVB ref = m_ref.getParentServiceReference();
ePtr<eDVBService> service;
if (!ref.valid())
ref = m_ref;
if(!eDVBDB::getInstance()->getService(ref, service))
{
// cached pids
for (int x = 0; x < eDVBService::cacheMax; ++x)
{
if (x == 5)
{
x += 3; // ignore cVTYPE, cACHANNEL, cAC3DELAY, cPCMDELAY
continue;
}
int entry = service->getCacheEntry((eDVBService::cacheID)x);
if (entry != -1)
{
if (eDVBService::cSUBTITLE == (eDVBService::cacheID)x)
{
entry = (entry&0xFFFF0000)>>16;
}
pids_to_record.insert(entry);
}
}
}
pids_to_record.insert(0); // PAT
if (program.pmtPid != -1)
pids_to_record.insert(program.pmtPid); // PMT
int timing_pid = -1, timing_stream_type = -1;
iDVBTSRecorder::timing_pid_type timing_pid_type = iDVBTSRecorder::none;
eDebugNoNewLine("RECORD: have %zd video stream(s)", program.videoStreams.size());
if (!program.videoStreams.empty())
{
eDebugNoNewLine(" (");
for (std::vector<eDVBServicePMTHandler::videoStream>::const_iterator
i(program.videoStreams.begin());
i != program.videoStreams.end(); ++i)
{
pids_to_record.insert(i->pid);
if (timing_pid == -1)
{
timing_pid = i->pid;
timing_stream_type = i->type;
timing_pid_type = iDVBTSRecorder::video_pid;
}
if (i != program.videoStreams.begin())
eDebugNoNewLine(", ");
eDebugNoNewLine("%04x", i->pid);
}
eDebugNoNewLine(")");
}
eDebugNoNewLine(", and %zd audio stream(s)", program.audioStreams.size());
if (!program.audioStreams.empty())
{
eDebugNoNewLine(" (");
for (std::vector<eDVBServicePMTHandler::audioStream>::const_iterator
i(program.audioStreams.begin());
i != program.audioStreams.end(); ++i)
{
pids_to_record.insert(i->pid);
if (timing_pid == -1)
{
timing_pid = i->pid;
timing_stream_type = i->type;
timing_pid_type = iDVBTSRecorder::audio_pid;
}
if (i != program.audioStreams.begin())
eDebugNoNewLine(", ");
eDebugNoNewLine("%04x", i->pid);
}
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 >= 0 && program.pcrPid < 0x1fff)
pids_to_record.insert(program.pcrPid);
eDebugNoNewLineEnd(", and the text pid is %04x", program.textPid);
if (program.textPid != -1)
pids_to_record.insert(program.textPid); // Videotext
if (m_record_ecm)
{
for (std::list<eDVBServicePMTHandler::program::capid_pair>::const_iterator i(program.caids.begin());
i != program.caids.end(); ++i)
{
if (i->capid >= 0) pids_to_record.insert(i->capid);
}
}
bool include_ait = eConfigManager::getConfigBoolValue("config.recording.include_ait");
if (include_ait)
{
/* add AIT pid (if any) */
if (program.aitPid >= 0) pids_to_record.insert(program.aitPid);
}
/* find out which pids are NEW and which pids are obsolete.. */
std::set<int> new_pids, obsolete_pids;
std::set_difference(pids_to_record.begin(), pids_to_record.end(),
m_pids_active.begin(), m_pids_active.end(),
std::inserter(new_pids, new_pids.begin()));
std::set_difference(
m_pids_active.begin(), m_pids_active.end(),
pids_to_record.begin(), pids_to_record.end(),
std::inserter(obsolete_pids, obsolete_pids.begin())
);
for (std::set<int>::iterator i(new_pids.begin()); i != new_pids.end(); ++i)
{
eDebug("ADD PID: %04x", *i);
m_record->addPID(*i);
}
for (std::set<int>::iterator i(obsolete_pids.begin()); i != obsolete_pids.end(); ++i)
{
eDebug("REMOVED PID: %04x", *i);
m_record->removePID(*i);
}
if (timing_pid != -1)
m_record->setTimingPID(timing_pid, timing_pid_type, timing_stream_type);
m_pids_active = pids_to_record;
if (m_state != stateRecording)
{
m_record->start();
m_state = stateRecording;
}
}
}
