lib/dvb/pmt.cpp

   1 #include <lib/base/eerror.h>
   2 #include <lib/dvb/pmt.h>
   3 #include <lib/dvb/specs.h>
   4 #include <lib/dvb/dvb.h>
   5 #include <lib/dvb/metaparser.h>
   6 #include <dvbsi++/ca_program_map_section.h>
   7
   8 eDVBServicePMTHandler::eDVBServicePMTHandler(int record)
   9         :m_pmt_pid(0xFFFF), m_ca_servicePtr(0)
  10 {
  11         m_record = record;
  12         eDVBResourceManager::getInstance(m_resourceManager);
  13         CONNECT(m_PMT.tableReady, eDVBServicePMTHandler::PMTready);
  14         CONNECT(m_PAT.tableReady, eDVBServicePMTHandler::PATready);
  15         eDebug("new PMT handler record: %d", m_record);
  16 }
  17
  18 eDVBServicePMTHandler::~eDVBServicePMTHandler()
  19 {
  20         eDebug("delete PMT handler record: %d", m_record);
  21         delete m_ca_servicePtr;
  22 }
  23
  24 void eDVBServicePMTHandler::channelStateChanged(iDVBChannel *channel)
  25 {
  26         int state;
  27         channel->getState(state);
  28
  29         if ((m_last_channel_state != iDVBChannel::state_ok)
  30                 && (state == iDVBChannel::state_ok) && (!m_demux))
  31         {
  32                 if (m_channel)
  33                         if (m_channel->getDemux(m_demux, m_record ? 0 : iDVBChannel::capDecode))
  34                                 eDebug("Allocating a demux for now tuned-in channel failed.");
  35
  36                 serviceEvent(eventTuned);
  37
  38                 if (m_demux)
  39                 {
  40                         eDebug("ok ... now we start!!");
  41
  42                         /* emit */ m_resourceManager->m_channelRunning(channel);
  43
  44                         m_PAT.begin(eApp, eDVBPATSpec(), m_demux);
  45
  46                         if ( m_service && !m_service->cacheEmpty() )
  47                                 serviceEvent(eventNewProgramInfo);
  48                 }
  49         } else if ((m_last_channel_state != iDVBChannel::state_failed) &&
  50                         (state == iDVBChannel::state_failed))
  51         {
  52                 eDebug("tune failed.");
  53                 serviceEvent(eventTuneFailed);
  54         }
  55 }
  56
  57 void eDVBServicePMTHandler::PMTready(int error)
  58 {
  59         if (error)
  60                 serviceEvent(eventNoPMT);
  61         else
  62         {
  63                 serviceEvent(eventNewProgramInfo);
  64                 if (!m_pvr_channel && !m_ca_servicePtr)   // don't send campmt to camd.socket for playbacked services
  65                         m_ca_servicePtr = new eDVBCAService(*this);
  66                 if (m_ca_servicePtr)
  67                         m_ca_servicePtr->buildCAPMT();
  68         }
  69 }
  70
  71 void eDVBServicePMTHandler::PATready(int)
  72 {
  73         eDebug("got PAT");
  74         ePtr<eTable<ProgramAssociationSection> > ptr;
  75         if (!m_PAT.getCurrent(ptr))
  76         {
  77                 int pmtpid = -1;
  78                 std::vector<ProgramAssociationSection*>::const_iterator i;
  79                 for (i = ptr->getSections().begin(); i != ptr->getSections().end(); ++i)
  80                 {
  81                         const ProgramAssociationSection &pat = **i;
  82                         ProgramAssociationConstIterator program;
  83                         for (program = pat.getPrograms()->begin(); program != pat.getPrograms()->end(); ++program)
  84                                 if (eServiceID((*program)->getProgramNumber()) == m_reference.getServiceID())
  85                                         pmtpid = (*program)->getProgramMapPid();
  86                 }
  87                 if (pmtpid == -1)
  88                         serviceEvent(eventNoPATEntry);
  89                 else
  90                 {
  91                         m_PMT.begin(eApp, eDVBPMTSpec(pmtpid, m_reference.getServiceID().get()), m_demux);
  92                         m_pmt_pid = pmtpid;
  93                 }
  94         } else
  95                 serviceEvent(eventNoPAT);
  96 }
  97
  98 int eDVBServicePMTHandler::getProgramInfo(struct program &program)
  99 {
 100         ePtr<eTable<ProgramMapSection> > ptr;
 101
 102         program.videoStreams.clear();
 103         program.audioStreams.clear();
 104         program.pcrPid = -1;
 105         program.pmtPid = m_pmt_pid < 0x1fff ? m_pmt_pid : -1;
 106
 107         if (!m_PMT.getCurrent(ptr))
 108         {
 109                 std::vector<ProgramMapSection*>::const_iterator i;
 110                 for (i = ptr->getSections().begin(); i != ptr->getSections().end(); ++i)
 111                 {
 112                         const ProgramMapSection &pmt = **i;
 113                         program.pcrPid = pmt.getPcrPid();
 114
 115                         ElementaryStreamInfoConstIterator es;
 116                         for (es = pmt.getEsInfo()->begin(); es != pmt.getEsInfo()->end(); ++es)
 117                         {
 118                                 int isaudio = 0, isvideo = 0;
 119                                 videoStream video;
 120                                 audioStream audio;
 121
 122                                 video.pid = (*es)->getPid();
 123                                 audio.pid = (*es)->getPid();
 124
 125                                 switch ((*es)->getType())
 126                                 {
 127                                 case 0x01: // MPEG 1 video
 128                                 case 0x02: // MPEG 2 video
 129                                         isvideo = 1;
 130                                         break;
 131                                 case 0x03: // MPEG 1 audio
 132                                 case 0x04: // MPEG 2 audio:
 133                                         isaudio = 1;
 134                                         audio.type = audioStream::atMPEG;
 135                                         break;
 136                                 }
 137                                 if (isaudio)
 138                                         program.audioStreams.push_back(audio);
 139                                 if (isvideo)
 140                                         program.videoStreams.push_back(video);
 141                         }
 142                 }
 143                 return 0;
 144         }
 145         else if ( m_service && !m_service->cacheEmpty() )
 146         {
 147                 int vpid = m_service->getCachePID(eDVBService::cVPID),
 148                         apid_ac3 = m_service->getCachePID(eDVBService::cAPID),
 149                         apid_mpeg = m_service->getCachePID(eDVBService::cAC3PID),
 150                         pcrpid = m_service->getCachePID(eDVBService::cPCRPID),
 151                         cnt=0;
 152                 if ( vpid != -1 )
 153                 {
 154                         videoStream s;
 155                         s.pid = vpid;
 156                         program.videoStreams.push_back(s);
 157                         ++cnt;
 158                 }
 159                 if ( apid_ac3 != -1 )
 160                 {
 161                         audioStream s;
 162                         s.type = audioStream::atAC3;
 163                         s.pid = apid_ac3;
 164                         program.audioStreams.push_back(s);
 165                         ++cnt;
 166                 }
 167                 if ( apid_mpeg != -1 )
 168                 {
 169                         audioStream s;
 170                         s.type = audioStream::atMPEG;
 171                         s.pid = apid_mpeg;
 172                         program.audioStreams.push_back(s);
 173                         ++cnt;
 174                 }
 175                 if ( pcrpid != -1 )
 176                 {
 177                         ++cnt;
 178                         program.pcrPid = pcrpid;
 179                 }
 180                 if ( cnt )
 181                         return 0;
 182         }
 183         return -1;
 184 }
 185
 186 int eDVBServicePMTHandler::getDemux(ePtr<iDVBDemux> &demux)
 187 {
 188         demux = m_demux;
 189         if (demux)
 190                 return 0;
 191         else
 192                 return -1;
 193 }
 194
 195 int eDVBServicePMTHandler::getPVRChannel(ePtr<iDVBPVRChannel> &pvr_channel)
 196 {
 197         pvr_channel = m_pvr_channel;
 198         if (pvr_channel)
 199                 return 0;
 200         else
 201                 return -1;
 202 }
 203
 204 int eDVBServicePMTHandler::tune(eServiceReferenceDVB &ref)
 205 {
 206         RESULT res;
 207         m_reference = ref;
 208
 209                 /* is this a normal (non PVR) channel? */
 210         if (ref.path.empty())
 211         {
 212                 eDVBChannelID chid;
 213                 ref.getChannelID(chid);
 214                 res = m_resourceManager->allocateChannel(chid, m_channel);
 215                 eDebug("allocate Channel: res %d", res);
 216         } else
 217         {
 218                 eDVBMetaParser parser;
 219
 220                 if (parser.parseFile(ref.path))
 221                         eWarning("no .meta file found, trying original service ref.");
 222                 else
 223                         m_reference = parser.m_ref;
 224
 225                 eDebug("alloc PVR");
 226                         /* allocate PVR */
 227                 res = m_resourceManager->allocatePVRChannel(m_pvr_channel);
 228                 if (res)
 229                         eDebug("allocatePVRChannel failed!\n");
 230                 m_channel = m_pvr_channel;
 231         }
 232
 233         if (m_channel)
 234         {
 235                 m_channel->connectStateChange(
 236                         slot(*this, &eDVBServicePMTHandler::channelStateChanged),
 237                         m_channelStateChanged_connection);
 238                 m_last_channel_state = -1;
 239                 channelStateChanged(m_channel);
 240         } else
 241         {
 242                 serviceEvent(eventTuneFailed);
 243                 return res;
 244         }
 245
 246         if (m_pvr_channel)
 247                 m_pvr_channel->playFile(ref.path.c_str());
 248
 249         ePtr<iDVBChannelList> db;
 250         if (!m_resourceManager->getChannelList(db))
 251                 db->getService((eServiceReferenceDVB&)m_reference, m_service);
 252
 253         return res;
 254 }
 255
 256 void eDVBCAService::Connect()
 257 {
 258         memset(&m_servaddr, 0, sizeof(struct sockaddr_un));
 259         m_servaddr.sun_family = AF_UNIX;
 260         strcpy(m_servaddr.sun_path, "/tmp/camd.socket");
 261         m_clilen = sizeof(m_servaddr.sun_family) + strlen(m_servaddr.sun_path);
 262         m_sock = socket(PF_UNIX, SOCK_STREAM, 0);
 263         connect(m_sock, (struct sockaddr *) &m_servaddr, m_clilen);
 264         fcntl(m_sock, F_SETFL, O_NONBLOCK);
 265         int val=1;
 266         setsockopt(m_sock, SOL_SOCKET, SO_REUSEADDR, &val, 4);
 267 }
 268
 269 void eDVBCAService::buildCAPMT()
 270 {
 271         ePtr<eTable<ProgramMapSection> > ptr;
 272
 273         if (m_parent.m_PMT.getCurrent(ptr))
 274                 return;
 275
 276         std::vector<ProgramMapSection*>::const_iterator i=ptr->getSections().begin();
 277         if ( i != ptr->getSections().end() )
 278         {
 279                 CaProgramMapSection capmt(*i++, m_capmt == NULL ? 0x03 /*only*/: 0x05 /*update*/, 0x01 );
 280
 281                 while( i != ptr->getSections().end() )
 282                 {
 283 //                      eDebug("append");
 284                         capmt.append(*i++);
 285                 }
 286
 287                 // add our private descriptors to capmt
 288                 uint8_t tmp[10];
 289
 290                 tmp[0]=0x84;  // pmt pid
 291                 tmp[1]=0x02;
 292                 tmp[2]=m_parent.m_pmt_pid>>8;
 293                 tmp[3]=m_parent.m_pmt_pid&0xFF;
 294                 capmt.injectDescriptor(tmp, false);
 295
 296                 tmp[0] = 0x82; // demux
 297                 tmp[1] = 0x02;
 298                 m_parent.m_demux->getCADemuxID(tmp[3]); // read section data from demux number
 299                 tmp[2] = 1 << tmp[3];                   // descramble bitmask
 300                 capmt.injectDescriptor(tmp, false);
 301
 302                 tmp[0] = 0x81; // dvbnamespace
 303                 tmp[1] = 0x08;
 304                 tmp[2] = m_parent.m_reference.getDVBNamespace().get()>>24;
 305                 tmp[3]=(m_parent.m_reference.getDVBNamespace().get()>>16)&0xFF;
 306                 tmp[4]=(m_parent.m_reference.getDVBNamespace().get()>>8)&0xFF;
 307                 tmp[5]=m_parent.m_reference.getDVBNamespace().get()&0xFF;
 308                 tmp[6]=m_parent.m_reference.getTransportStreamID().get()>>8;
 309                 tmp[7]=m_parent.m_reference.getTransportStreamID().get()&0xFF;
 310                 tmp[8]=m_parent.m_reference.getOriginalNetworkID().get()>>8;
 311                 tmp[9]=m_parent.m_reference.getOriginalNetworkID().get()&0xFF;
 312                 capmt.injectDescriptor(tmp, false);
 313
 314                 if ( !m_capmt )
 315                         m_capmt = new uint8_t[2048];
 316
 317                 capmt.writeToBuffer(m_capmt);
 318         }
 319
 320         if ( m_sendstate != 0xFFFFFFFF )
 321                 m_sendstate=0;
 322         sendCAPMT();
 323 }
 324
 325 void eDVBCAService::sendCAPMT()
 326 {
 327         if ( m_sendstate && m_sendstate != 0xFFFFFFFF ) // broken pipe retry
 328         {
 329                 ::close(m_sock);
 330                 Connect();
 331         }
 332
 333         int wp=0;
 334         if ( m_capmt[3] & 0x80 )
 335         {
 336                 int i=0;
 337                 int lenbytes = m_capmt[3] & ~0x80;
 338                 while(i < lenbytes)
 339                         wp |= (m_capmt[4+i] << (8 * i++));
 340                 wp+=4;
 341                 wp+=lenbytes;
 342         }
 343         else
 344         {
 345                 wp = m_capmt[3];
 346                 wp+=4;
 347         }
 348
 349         if ( write(m_sock, m_capmt, wp) == wp )
 350         {
 351                 m_sendstate=0xFFFFFFFF;
 352                 eDebug("[eDVBCAHandler] send %d bytes",wp);
 353 #if 1
 354                 for(int i=0;i<wp;i++)
 355                         eDebugNoNewLine("%02x ", m_capmt[i]);
 356                 eDebug("");
 357 #endif
 358         }
 359         else
 360         {
 361                 switch(m_sendstate)
 362                 {
 363                         case 0xFFFFFFFF:
 364                                 ++m_sendstate;
 365                                 m_retryTimer.start(0,true);
 366 //                              eDebug("[eDVBCAHandler] send failed .. immediate retry");
 367                                 break;
 368                         default:
 369                                 m_retryTimer.start(5000,true);
 370 //                              eDebug("[eDVBCAHandler] send failed .. retry in 5 sec");
 371                                 break;
 372                 }
 373                 ++m_sendstate;
 374         }
 375 }