code.vuplus.com Git - vuplus_dvbapp/blob - lib/dvb/fcc.cpp

   1 #include <lib/dvb/fcc.h>
   2 #include <lib/nav/core.h>
   3 #include <lib/base/nconfig.h>
   4 #include <lib/base/eerror.h>
   5 #include <lib/python/python.h>
   6
   7 //#define FCC_DEBUG
   8
   9 void FCCServiceChannels::addFCCService(const eServiceReference &service)
  10 {
  11         eDVBChannelID fcc_chid;
  12
  13         ((const eServiceReferenceDVB&)service).getChannelID(fcc_chid);
  14
  15         if (m_fcc_chids.find(fcc_chid) != m_fcc_chids.end())
  16                 m_fcc_chids[fcc_chid] += 1;
  17         else
  18                 m_fcc_chids[fcc_chid] = 1;
  19 }
  20
  21 void FCCServiceChannels::removeFCCService(const eServiceReference &service)
  22 {
  23         eDVBChannelID fcc_chid;
  24         ((const eServiceReferenceDVB&)service).getChannelID(fcc_chid);
  25
  26         if (m_fcc_chids.find(fcc_chid) != m_fcc_chids.end())
  27         {
  28                 m_fcc_chids[fcc_chid] -= 1;
  29
  30                 if (m_fcc_chids[fcc_chid] == 0)
  31                         m_fcc_chids.erase(fcc_chid);
  32         }
  33 }
  34
  35 int FCCServiceChannels::getFCCChannelID(std::map<eDVBChannelID, int> &fcc_chids)
  36 {
  37         if (!m_fcc_chids.size()) return -1;
  38
  39         fcc_chids = m_fcc_chids;
  40         return 0;
  41 }
  42
  43 eFCCServiceManager *eFCCServiceManager::m_instance = (eFCCServiceManager*)0;
  44
  45 eFCCServiceManager* eFCCServiceManager::getInstance()
  46 {
  47         return m_instance;
  48 }
  49
  50 eFCCServiceManager::eFCCServiceManager(eNavigation *navptr)
  51         :m_core(navptr), m_fcc_enable(false)
  52 {
  53         if (!m_instance)
  54         {
  55                 m_instance = this;
  56         }
  57 }
  58
  59 eFCCServiceManager::~eFCCServiceManager()
  60 {
  61         if (m_instance == this)
  62         {
  63                 m_instance = 0;
  64         }
  65 }
  66
  67 RESULT eFCCServiceManager::playFCCService(const eServiceReference &ref, ePtr<iPlayableService> &service)
  68 {
  69         std::map< ePtr<iPlayableService>, FCCServiceElem >::iterator it = m_FCCServices.begin();
  70         for (;it != m_FCCServices.end();++it)
  71         {
  72                 ASSERT (ref != it->second.m_service_reference);
  73         }
  74
  75         ASSERT(m_core->m_servicehandler);
  76         RESULT res = m_core->m_servicehandler->play(ref, service);
  77         if (res)
  78                 service = 0;
  79         else
  80         {
  81                 ePtr<eConnection> conn;
  82                 service->connectEvent(slot(*this, &eFCCServiceManager::FCCEvent), conn);
  83
  84                 FCCServiceElem elem = {ref, conn, fcc_state_preparing};
  85                 m_FCCServices[service] = elem;
  86
  87                 res = service->start();
  88         }
  89
  90         printFCCServices();
  91
  92         return res;
  93 }
  94
  95 void eFCCServiceManager::FCCEvent(iPlayableService* service, int event)
  96 {
  97         std::map<ePtr<iPlayableService>, FCCServiceElem >::iterator it = m_FCCServices.find(service);
  98         if (it == m_FCCServices.end())
  99         {
 100                 eDebug("[eFCCServiceManager] event for non registered FCC service");
 101                 return;
 102         }
 103
 104         switch (event)
 105         {
 106                 case iPlayableService::evStart:
 107                 {
 108                         m_fccServiceChannels.addFCCService(it->second.m_service_reference);
 109                         break;
 110                 }
 111                 case iPlayableService::evStopped:
 112                 {
 113                         m_fccServiceChannels.removeFCCService(it->second.m_service_reference);
 114                         break;
 115                 }
 116                 case iPlayableService::evTuneFailed:
 117                 case iPlayableService::evFccFailed:
 118                 {
 119                         eDebug("[eFCCServiceManager][%s] set service to state failed.", it->second.m_service_reference.toString().c_str());
 120                         it->second.m_state = fcc_state_failed;
 121                         break;
 122                 }
 123         }
 124         m_fcc_event(event);
 125 }
 126
 127 RESULT eFCCServiceManager::cleanupFCCService()
 128 {
 129         if (m_FCCServices.size())
 130         {
 131                 std::map<ePtr<iPlayableService>, FCCServiceElem >::iterator it = m_FCCServices.begin();
 132                 for (;it != m_FCCServices.end();++it)
 133                 {
 134                         eDebug("[eFCCServiceManager] stop FCC service sref : %s", it->second.m_service_reference.toString().c_str());
 135                         it->first->stop();
 136                 }
 137
 138                 m_FCCServices.clear();
 139         }
 140         return 0;
 141 }
 142
 143 RESULT eFCCServiceManager::stopFCCService(const eServiceReference &sref)
 144 {
 145         if (m_FCCServices.size())
 146         {
 147                 std::map<ePtr<iPlayableService>, FCCServiceElem >::iterator it = m_FCCServices.begin();
 148                 for (; it != m_FCCServices.end();)
 149                 {
 150                         if (it->second.m_service_reference == sref)
 151                         {
 152                                 eDebug("[eFCCServiceManager] stop FCC service sref : %s", it->second.m_service_reference.toString().c_str());
 153                                 it->first->stop();
 154                                 m_FCCServices.erase(it++);
 155                         }
 156                         else
 157                         {
 158                                 ++it;
 159                         }
 160                 }
 161                 printFCCServices();
 162         }
 163         return 0;
 164 }
 165
 166 RESULT eFCCServiceManager::stopFCCService()
 167 {
 168         if (m_FCCServices.size())
 169         {
 170                 std::map<ePtr<iPlayableService>, FCCServiceElem >::iterator it = m_FCCServices.begin();
 171                 for (; it != m_FCCServices.end();)
 172                 {
 173                         if (it->second.m_state == fcc_state_failed)
 174                         {
 175                                 eDebug("[eFCCServiceManager] stop FCC service sref : %s", it->second.m_service_reference.toString().c_str());
 176                                 it->first->stop();
 177                                 m_FCCServices.erase(it++);
 178                         }
 179                         else
 180                         {
 181                                 ++it;
 182                         }
 183                 }
 184
 185                 printFCCServices();
 186         }
 187         return 0;
 188 }
 189
 190 RESULT eFCCServiceManager::tryFCCService(const eServiceReference &sref, ePtr<iPlayableService> &service)
 191 {
 192         ePtr<iPlayableService> new_service = 0;
 193
 194         printFCCServices();
 195
 196         int get_fcc_decoding = 0;
 197
 198         /* stop previous decoding service */
 199         std::map< ePtr<iPlayableService>, FCCServiceElem >::iterator it;
 200         for (it = m_FCCServices.begin();it != m_FCCServices.end();++it)
 201         {
 202                 if (it->second.m_state == fcc_state_decoding)
 203                 {
 204                         ASSERT(get_fcc_decoding == 0);
 205                         get_fcc_decoding = 1;
 206
 207                         /* send end event */
 208                         m_core->m_event(iPlayableService::evEnd);
 209
 210                         /* kill service and event */
 211                         m_core->m_service_event_conn = 0;
 212                         m_core->m_runningService = 0;
 213
 214                         /* connect to fcc event */
 215                         ePtr<eConnection> conn;
 216                         it->first->connectEvent(slot(*this, &eFCCServiceManager::FCCEvent), conn);
 217                         it->second.m_service_event_conn = conn;
 218                         it->second.m_state = fcc_state_preparing;
 219
 220                         /* switch to FCC prepare state */
 221                         it->first->start();
 222
 223                         /* update FCCServiceChannels */
 224                         m_fccServiceChannels.addFCCService(it->second.m_service_reference);
 225                 }
 226         }
 227
 228         /* search new service */
 229         for (it = m_FCCServices.begin();it != m_FCCServices.end();++it)
 230         {
 231                 if (it->second.m_service_reference == sref)
 232                 {
 233                         eDebug("[eFCCServiceManager] use FCC service sref : %s", it->second.m_service_reference.toString().c_str());
 234                         it->second.m_service_event_conn = 0; /* disconnect FCC event */
 235                         it->second.m_state = fcc_state_decoding;
 236                         new_service = it->first;
 237                         m_fccServiceChannels.removeFCCService(it->second.m_service_reference);
 238                         break;
 239                 }
 240         }
 241
 242         if (new_service)
 243         {
 244                 service = new_service;
 245         }
 246
 247         else /* If new service is not found in FCC service list, cleanup all FCC prepared services and get new FCC service. */
 248         {
 249                 cleanupFCCService();
 250                 m_core->stopService();
 251                 if (eFCCServiceManager::checkAvailable(sref))
 252                 {
 253                         ASSERT(m_core->m_servicehandler);
 254                         m_core->m_servicehandler->play(sref, service);
 255
 256                         if (service)
 257                         {
 258                                 FCCServiceElem elem = {sref, 0, fcc_state_decoding};
 259                                 m_FCCServices[service] = elem;
 260                                 service->start(); // do FCC preparing
 261                         }
 262                 }
 263                 else
 264                 {
 265                         return -1;
 266                 }
 267         }
 268
 269         printFCCServices();
 270
 271         return 0;
 272 }
 273
 274 int eFCCServiceManager::isLocked(ePtr<iPlayableService> service)
 275 {
 276         ePtr<iFrontendInformation> ptr;
 277         service->frontendInfo(ptr);
 278         return ptr->getFrontendInfo(iDVBFrontend_ENUMS::locked);
 279 }
 280
 281 PyObject *eFCCServiceManager::getFCCServiceList()
 282 {
 283         ePyObject dest = PyDict_New();
 284         if (dest)
 285         {
 286                 std::map< ePtr<iPlayableService>, FCCServiceElem >::iterator it = m_FCCServices.begin();
 287                 for (;it != m_FCCServices.end();++it)
 288                 {
 289                         ePyObject tplist = PyList_New(0);
 290                         PyList_Append(tplist, PyInt_FromLong((long)it->second.m_state));
 291                         PyList_Append(tplist, PyInt_FromLong((long)isLocked(it->first)));
 292                         PyDict_SetItemString(dest, it->second.m_service_reference.toString().c_str(), tplist);
 293                         Py_DECREF(tplist);
 294                 }
 295         }
 296
 297         else
 298                 Py_RETURN_NONE;
 299         return dest;
 300 }
 301
 302 void eFCCServiceManager::printFCCServices()
 303 {
 304 #ifdef FCC_DEBUG
 305         eDebug("                                                [eFCCServiceManager::printFCCServices][*] total size : %d", m_FCCServices.size());
 306
 307         std::map< ePtr<iPlayableService>, FCCServiceElem >::iterator it = m_FCCServices.begin();
 308         for (;it != m_FCCServices.end();++it)
 309         {
 310                 eDebug("                                                [eFCCServiceManager::printFCCServices][*] sref : %s, state : %d, tune : %d", it->second.m_service_reference.toString().c_str(), it->second.m_state, isLocked(it->first));
 311         }
 312 #else
 313         ;
 314 #endif
 315 }
 316
 317 int eFCCServiceManager::getFCCChannelID(std::map<eDVBChannelID, int> &fcc_chids)
 318 {
 319         eFCCServiceManager *fcc_mng = eFCCServiceManager::getInstance();
 320         if (!fcc_mng) return -1;
 321         return fcc_mng->m_fccServiceChannels.getFCCChannelID(fcc_chids);
 322 }
 323
 324 bool eFCCServiceManager::checkAvailable(const eServiceReference &ref)
 325 {
 326         int serviceType = ref.getData(0);
 327         eFCCServiceManager *fcc_mng = eFCCServiceManager::getInstance();
 328
 329         if (ref.path.empty() && (serviceType != 2) && (serviceType != 10) && fcc_mng) // no PVR, streaming, radio channel..
 330                 return fcc_mng->isEnable();
 331         return false;
 332 }
 333
 334 DEFINE_REF(eFCCServiceManager);
 335