DTC::ChannelInfoList* Channel::GetChannelInfoList( uint nSourceID,
uint nStartIndex,
uint nCount,
bool bOnlyVisible,
bool bDetails )
{
ChannelInfoList chanList;
uint nTotalAvailable = 0;
chanList = ChannelUtil::LoadChannels( 0, 0, nTotalAvailable, bOnlyVisible,
ChannelUtil::kChanOrderByChanNum,
ChannelUtil::kChanGroupByChanid,
nSourceID ); //, nChanGroupID
// ----------------------------------------------------------------------
// Build Response
// ----------------------------------------------------------------------
DTC::ChannelInfoList *pChannelInfos = new DTC::ChannelInfoList();
//uint nTotalAvailable = static_cast<uint>(chanList.size());
nStartIndex = (nStartIndex > 0) ? min( nStartIndex, nTotalAvailable ) : 0;
nCount = (nCount > 0) ? min( nCount, nTotalAvailable ) : nTotalAvailable;
int nEndIndex = min((nStartIndex + nCount), nTotalAvailable );
ChannelInfoList::iterator chanIt;
for( chanIt = chanList.begin(); chanIt != chanList.end(); ++chanIt)
{
DTC::ChannelInfo *pChannelInfo = pChannelInfos->AddNewChannelInfo();
ChannelInfo channelInfo = (*chanIt);
if (!FillChannelInfo(pChannelInfo, channelInfo, bDetails))
throw( QString("Channel ID appears invalid."));
}
int nCurPage = 0, nTotalPages = 0;
if (nCount == 0)
nTotalPages = 1;
else
nTotalPages = (int)ceil((float)nTotalAvailable / nCount);
if (nTotalPages == 1)
nCurPage = 1;
else
{
nCurPage = (int)ceil((float)nStartIndex / nCount) + 1;
}
pChannelInfos->setStartIndex ( nStartIndex );
pChannelInfos->setCount ( nCount );
pChannelInfos->setCurrentPage ( nCurPage );
pChannelInfos->setTotalPages ( nTotalPages );
pChannelInfos->setTotalAvailable( nTotalAvailable );
pChannelInfos->setAsOf ( MythDate::current() );
pChannelInfos->setVersion ( MYTH_BINARY_VERSION );
pChannelInfos->setProtoVer ( MYTH_PROTO_VERSION );
return pChannelInfos;
}
ChannelList ChannelData::channelList(int sourceId)
{
ChannelList retList;
ChannelInfoList channelList = ChannelUtil::GetChannels(sourceId, false);
ChannelInfoList::iterator it = channelList.begin();
for ( ; it != channelList.end(); ++it)
{
QString chanName = (*it).name;
QString key = normalizeChannelKey(chanName);
retList.insert(key, *it);
}
return retList;
}
ChannelGroupConfig::ChannelGroupConfig(QString _name)
: name(_name)
{
VerticalConfigurationGroup *cgroup;
HorizontalConfigurationGroup *columns;
ChannelInfoList chanlist = ChannelUtil::GetChannels(0, true, "channum, callsign");
ChannelUtil::SortChannels(chanlist, "channum", true);
ChannelInfoList::iterator it = chanlist.begin();
int i,j = 0;
int p = 1;
int pages = (int)((float)chanlist.size() / 8.0 / 3.0 + 0.5);
do
{
columns = new HorizontalConfigurationGroup(false,false,false,false);
columns->setLabel(getName() + " " +
QObject::tr("Channel Group - Page ") + QString("%1").arg(p) +
QObject::tr("of") + QString("%1").arg(pages));
for (j = 0; ((j < 3) && (it < chanlist.end())); ++j)
{
cgroup = new VerticalConfigurationGroup(false,false,false,false);
for (i = 0; ((i < 8) && (it < chanlist.end())); ++i)
{
cgroup->addChild(new ChannelCheckBox(*this, it->chanid, it->channum, it->name, _name));
++it;
}
columns->addChild(cgroup);
}
++p;
addChild(columns);
} while (it < chanlist.end());
}
/** \fn ChannelBase::InitializeInputs(void)
* \brief Fills in input map from DB
*/
bool ChannelBase::InitializeInputs(void)
{
ClearInputMap();
uint cardid = GetCardID();
if (!cardid)
{
LOG(VB_GENERAL, LOG_ERR,
"InitializeInputs(): Programmer error, cardid invalid.");
return false;
}
MSqlQuery query(MSqlQuery::InitCon());
query.prepare(
"SELECT cardinputid, "
" inputname, startchan, "
" tunechan, externalcommand, "
" sourceid, livetvorder "
"FROM cardinput "
"WHERE cardid = :CARDID");
query.bindValue(":CARDID", cardid);
if (!query.exec() || !query.isActive())
{
MythDB::DBError("InitializeInputs", query);
return false;
}
else if (!query.size())
{
LOG(VB_GENERAL, LOG_ERR, "InitializeInputs(): "
"\n\t\t\tCould not get inputs for the capturecard."
"\n\t\t\tPerhaps you have forgotten to bind video"
"\n\t\t\tsources to your card's inputs?");
return false;
}
m_allchannels.clear();
QString order = gCoreContext->GetSetting("ChannelOrdering", "channum");
while (query.next())
{
uint sourceid = query.value(5).toUInt();
ChannelInfoList channels = ChannelUtil::GetChannels(sourceid, false);
ChannelUtil::SortChannels(channels, order);
m_inputs[query.value(0).toUInt()] = new ChannelInputInfo(
query.value(1).toString(), query.value(2).toString(),
query.value(3).toString(), query.value(4).toString(),
sourceid, cardid,
query.value(0).toUInt(), query.value(5).toUInt(),
0, channels);
if (!IsExternalChannelChangeSupported() &&
!m_inputs[query.value(0).toUInt()]->externalChanger.isEmpty())
{
LOG(VB_GENERAL, LOG_WARNING, LOC + "External Channel changer is "
"set, but this device does not support it.");
m_inputs[query.value(0).toUInt()]->externalChanger.clear();
}
m_allchannels.insert(m_allchannels.end(),
channels.begin(), channels.end());
}
ChannelUtil::SortChannels(m_allchannels, order, true);
m_currentInputID = GetStartInput(cardid);
// In case that initial input is not set
if (m_currentInputID == -1)
m_currentInputID = GetNextInputNum();
// print em
InputMap::const_iterator it;
for (it = m_inputs.begin(); it != m_inputs.end(); ++it)
{
LOG(VB_CHANNEL, LOG_INFO, LOC +
QString("Input #%1: '%2' schan(%3) sourceid(%4) ccid(%5)")
.arg(it.key()).arg((*it)->name).arg((*it)->startChanNum)
.arg((*it)->sourceid).arg((*it)->cardid));
}
LOG(VB_CHANNEL, LOG_INFO, LOC + QString("Current Input #%1: '%2'")
.arg(GetCurrentInputNum()).arg(GetCurrentInput()));
return m_inputs.size();
}
bool ChannelBase::Init(QString &inputname, QString &startchannel, bool setchan)
{
bool ok;
if (!setchan)
ok = inputname.isEmpty() ? false : IsTunable(inputname, startchannel);
else if (inputname.isEmpty())
ok = SetChannelByString(startchannel);
else
ok = SwitchToInput(inputname, startchannel);
if (ok)
return true;
// try to find a valid channel if given start channel fails.
QString msg1 = QString("Setting start channel '%1' failed, ")
.arg(startchannel);
QString msg2 = "and we failed to find any suitible channels on any input.";
bool msg_error = true;
QStringList inputs = GetConnectedInputs();
// Note we use qFind rather than std::find() for ulibc compat (#4507)
QStringList::const_iterator start =
qFind(inputs.begin(), inputs.end(), inputname);
start = (start == inputs.end()) ? inputs.begin() : start;
if (start != inputs.end())
{
LOG(VB_CHANNEL, LOG_INFO, LOC +
QString("Looking for startchannel '%1' on input '%2'")
.arg(startchannel).arg(*start));
}
// Attempt to find an input for the requested startchannel
QStringList::const_iterator it = start;
while (it != inputs.end())
{
ChannelInfoList channels = GetChannels(*it);
ChannelInfoList::const_iterator cit = channels.begin();
for (; cit != channels.end(); ++cit)
{
if ((*cit).channum == startchannel &&
IsTunable(*it, startchannel))
{
inputname = *it;
LOG(VB_CHANNEL, LOG_INFO, LOC +
QString("Found startchannel '%1' on input '%2'")
.arg(startchannel).arg(inputname));
return true;
}
}
++it;
it = (it == inputs.end()) ? inputs.begin() : it;
if (it == start)
break;
}
it = start;
while (it != inputs.end() && !ok)
{
uint mplexid_restriction = 0;
ChannelInfoList channels = GetChannels(*it);
if (channels.size() &&
IsInputAvailable(GetInputByName(*it), mplexid_restriction))
{
uint chanid = ChannelUtil::GetNextChannel(
channels, channels[0].chanid,
mplexid_restriction, CHANNEL_DIRECTION_UP);
ChannelInfoList::const_iterator cit =
find(channels.begin(), channels.end(), chanid);
if (chanid && cit != channels.end())
{
if (!setchan)
{
ok = IsTunable(*it, (mplexid_restriction) ?
(*cit).channum : startchannel);
}
else
ok = SwitchToInput(*it, (*cit).channum);
if (ok)
{
inputname = *it;
if (mplexid_restriction)
{
startchannel = (*cit).channum;
startchannel.detach();
}
msg2 = QString("selected to '%1' on input '%2' instead.")
.arg(startchannel).arg(inputname);
msg_error = false;
}
}
}
++it;
it = (it == inputs.end()) ? inputs.begin() : it;
if (it == start)
break;
}
LOG(VB_GENERAL, ((msg_error) ? LOG_ERR : LOG_WARNING), LOC +
msg1 + "\n\t\t\t" + msg2);
return ok;
}
DTC::ProgramGuide *Guide::GetProgramGuide( const QDateTime &rawStartTime ,
const QDateTime &rawEndTime ,
bool bDetails,
int nChannelGroupId,
int nStartIndex,
int nCount)
{
if (!rawStartTime.isValid())
throw( "StartTime is invalid" );
if (!rawEndTime.isValid())
throw( "EndTime is invalid" );
QDateTime dtStartTime = rawStartTime.toUTC();
QDateTime dtEndTime = rawEndTime.toUTC();
if (dtEndTime < dtStartTime)
throw( "EndTime is before StartTime");
if (nStartIndex <= 0)
nStartIndex = 0;
if (nCount <= 0)
nCount = 20000;
// ----------------------------------------------------------------------
// Load the channel list
// ----------------------------------------------------------------------
uint nTotalAvailable = 0;
ChannelInfoList chanList = ChannelUtil::LoadChannels(nStartIndex, nCount,
nTotalAvailable, true,
ChannelUtil::kChanOrderByChanNum,
ChannelUtil::kChanGroupByCallsign,
0,
nChannelGroupId);
// ----------------------------------------------------------------------
// Build SQL statement for Program Listing
// ----------------------------------------------------------------------
ProgramList schedList;
MSqlBindings bindings;
QString sWhere = "program.chanid = :CHANID "
"AND program.endtime >= :STARTDATE "
"AND program.starttime < :ENDDATE "
"AND program.starttime >= :STARTDATELIMIT "
"AND program.manualid = 0"; // Omit 'manual' recordings scheds
QString sGroupBy = "program.starttime, channel.channum,"
"channel.callsign, program.title";
QString sOrderBy = "program.starttime";
bindings[":STARTDATE" ] = dtStartTime;
bindings[":STARTDATELIMIT"] = dtStartTime.addDays(-1);
bindings[":ENDDATE" ] = dtEndTime;
// ----------------------------------------------------------------------
// Get all Pending Scheduled Programs
// ----------------------------------------------------------------------
// NOTE: Fetching this information directly from the schedule is
// significantly faster than using ProgramInfo::LoadFromScheduler()
Scheduler *scheduler = dynamic_cast<Scheduler*>(gCoreContext->GetScheduler());
if (scheduler)
scheduler->GetAllPending(schedList);
// ----------------------------------------------------------------------
// Build Response
// ----------------------------------------------------------------------
DTC::ProgramGuide *pGuide = new DTC::ProgramGuide();
ChannelInfoList::iterator chan_it;
for (chan_it = chanList.begin(); chan_it != chanList.end(); ++chan_it)
{
// Create ChannelInfo Object
DTC::ChannelInfo *pChannel = NULL;
pChannel = pGuide->AddNewChannel();
FillChannelInfo( pChannel, (*chan_it), bDetails );
// Load the list of programmes for this channel
ProgramList progList;
bindings[":CHANID"] = (*chan_it).chanid;
LoadFromProgram( progList, sWhere, sOrderBy, sOrderBy, bindings,
schedList );
// Create Program objects and add them to the channel object
ProgramList::iterator progIt;
for( progIt = progList.begin(); progIt != progList.end(); ++progIt)
{
DTC::Program *pProgram = pChannel->AddNewProgram();
FillProgramInfo( pProgram, *progIt, false, bDetails, false ); // No cast info
}
}
// ----------------------------------------------------------------------
pGuide->setStartTime ( dtStartTime );
pGuide->setEndTime ( dtEndTime );
pGuide->setDetails ( bDetails );
pGuide->setStartIndex ( nStartIndex );
pGuide->setCount ( chanList.size() );
pGuide->setTotalAvailable( nTotalAvailable );
pGuide->setAsOf ( MythDate::current() );
pGuide->setVersion ( MYTH_BINARY_VERSION );
pGuide->setProtoVer ( MYTH_PROTO_VERSION );
return pGuide;
}
