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 <lib/dvb_ci/dvbci.h>
   7 #include <dvbsi++/ca_program_map_section.h>
   8 #include <dvbsi++/descriptor_tag.h>
   9 #include <dvbsi++/iso639_language_descriptor.h>
  10 #include <dvbsi++/component_descriptor.h>
  11
  12 int eDVBServicePMTHandler::m_count;
  13
  14 eDVBServicePMTHandler::eDVBServicePMTHandler(int record)
  15         :m_ca_servicePtr(0)
  16 {
  17         m_record = record;
  18         eDVBResourceManager::getInstance(m_resourceManager);
  19         CONNECT(m_PMT.tableReady, eDVBServicePMTHandler::PMTready);
  20         CONNECT(m_PAT.tableReady, eDVBServicePMTHandler::PATready);
  21         eDebug("new PMT handler record: %d", m_record);
  22         ++m_count;
  23 }
  24
  25 eDVBServicePMTHandler::~eDVBServicePMTHandler()
  26 {
  27         eDebug("delete PMT handler record: %d", m_record);
  28         if (m_ca_servicePtr)
  29         {
  30                 eDebug("unregister caservice");
  31                 uint8_t demux_num;
  32                 m_demux->getCADemuxID(demux_num);
  33                 ePtr<eTable<ProgramMapSection> > ptr;
  34                 m_PMT.getCurrent(ptr);
  35                 eDVBCAService::unregister_service(m_reference, demux_num, ptr);
  36                 eDVBCIInterfaces::getInstance()->removePMTHandler(this);
  37         }
  38         --m_count;
  39 }
  40
  41 void eDVBServicePMTHandler::channelStateChanged(iDVBChannel *channel)
  42 {
  43         int state;
  44         channel->getState(state);
  45
  46         if ((m_last_channel_state != iDVBChannel::state_ok)
  47                 && (state == iDVBChannel::state_ok) && (!m_demux))
  48         {
  49                 if (m_channel)
  50                         if (m_channel->getDemux(m_demux, m_record ? 0 : iDVBChannel::capDecode))
  51                                 eDebug("Allocating a demux for now tuned-in channel failed.");
  52
  53                 serviceEvent(eventTuned);
  54
  55                 if (m_demux)
  56                 {
  57                         eDebug("ok ... now we start!!");
  58
  59                         /* emit */ m_resourceManager->m_channelRunning(channel);
  60
  61                         m_PAT.begin(eApp, eDVBPATSpec(), m_demux);
  62
  63                         if ( m_service && !m_service->cacheEmpty() )
  64                                 serviceEvent(eventNewProgramInfo);
  65                 }
  66         } else if ((m_last_channel_state != iDVBChannel::state_failed) &&
  67                         (state == iDVBChannel::state_failed))
  68         {
  69                 eDebug("tune failed.");
  70                 serviceEvent(eventTuneFailed);
  71         }
  72 }
  73
  74 void eDVBServicePMTHandler::PMTready(int error)
  75 {
  76         if (error)
  77                 serviceEvent(eventNoPMT);
  78         else
  79         {
  80                 serviceEvent(eventNewProgramInfo);
  81                 if (!m_pvr_channel)
  82                 {
  83                         if(!m_ca_servicePtr)   // don't send campmt to camd.socket for playbacked services
  84                         {
  85                                 uint8_t demux_num;
  86                                 m_demux->getCADemuxID(demux_num);
  87                                 eDVBCAService::register_service(m_reference, demux_num, m_ca_servicePtr);
  88                                 eDVBCIInterfaces::getInstance()->addPMTHandler(this);
  89                         }
  90                         eDVBCIInterfaces::getInstance()->gotPMT(this);
  91                 }
  92                 if (m_ca_servicePtr)
  93                 {
  94                         ePtr<eTable<ProgramMapSection> > ptr;
  95                         if (!m_PMT.getCurrent(ptr))
  96                                 m_ca_servicePtr->buildCAPMT(ptr);
  97                         else
  98                                 eDebug("eDVBServicePMTHandler cannot call buildCAPMT");
  99                 }
 100         }
 101 }
 102
 103 void eDVBServicePMTHandler::PATready(int)
 104 {
 105         eDebug("got PAT");
 106         ePtr<eTable<ProgramAssociationSection> > ptr;
 107         if (!m_PAT.getCurrent(ptr))
 108         {
 109                 int pmtpid = -1;
 110                 std::vector<ProgramAssociationSection*>::const_iterator i;
 111                 for (i = ptr->getSections().begin(); i != ptr->getSections().end(); ++i)
 112                 {
 113                         const ProgramAssociationSection &pat = **i;
 114                         ProgramAssociationConstIterator program;
 115                         for (program = pat.getPrograms()->begin(); program != pat.getPrograms()->end(); ++program)
 116                                 if (eServiceID((*program)->getProgramNumber()) == m_reference.getServiceID())
 117                                         pmtpid = (*program)->getProgramMapPid();
 118                 }
 119                 if (pmtpid == -1)
 120                         serviceEvent(eventNoPATEntry);
 121                 else
 122                         m_PMT.begin(eApp, eDVBPMTSpec(pmtpid, m_reference.getServiceID().get()), m_demux);
 123         } else
 124                 serviceEvent(eventNoPAT);
 125 }
 126
 127 int eDVBServicePMTHandler::getProgramInfo(struct program &program)
 128 {
 129         ePtr<eTable<ProgramMapSection> > ptr;
 130
 131         program.videoStreams.clear();
 132         program.audioStreams.clear();
 133         program.pcrPid = -1;
 134
 135         if (!m_PMT.getCurrent(ptr))
 136         {
 137                 eDVBTableSpec table_spec;
 138                 ptr->getSpec(table_spec);
 139                 program.pmtPid = table_spec.pid < 0x1fff ? table_spec.pid : -1;
 140                 std::vector<ProgramMapSection*>::const_iterator i;
 141                 for (i = ptr->getSections().begin(); i != ptr->getSections().end(); ++i)
 142                 {
 143                         const ProgramMapSection &pmt = **i;
 144                         program.pcrPid = pmt.getPcrPid();
 145
 146                         ElementaryStreamInfoConstIterator es;
 147                         for (es = pmt.getEsInfo()->begin(); es != pmt.getEsInfo()->end(); ++es)
 148                         {
 149                                 int isaudio = 0, isvideo = 0;
 150                                 videoStream video;
 151                                 audioStream audio;
 152
 153                                 video.pid = (*es)->getPid();
 154                                 audio.pid = (*es)->getPid();
 155
 156                                 switch ((*es)->getType())
 157                                 {
 158                                 case 0x01: // MPEG 1 video
 159                                 case 0x02: // MPEG 2 video
 160                                         isvideo = 1;
 161                                         break;
 162                                 case 0x03: // MPEG 1 audio
 163                                 case 0x04: // MPEG 2 audio:
 164                                         isaudio = 1;
 165                                         audio.type = audioStream::atMPEG;
 166                                         break;
 167                                 case 0x06: // PES Private
 168                                                 /* PES private can contain AC-3, DTS or lots of other stuff.
 169                                                    check descriptors to get the exact type. */
 170                                         for (DescriptorConstIterator desc = (*es)->getDescriptors()->begin();
 171                                                         desc != (*es)->getDescriptors()->end(); ++desc)
 172                                         {
 173                                                 switch ((*desc)->getTag())
 174                                                 {
 175                                                 case AC3_DESCRIPTOR:
 176                                                         isaudio = 1;
 177                                                         audio.type = audioStream::atAC3;
 178                                                         break;
 179                                                 }
 180                                         }
 181                                         break;
 182                                 }
 183                                 if (isaudio)
 184                                 {
 185                                         for (DescriptorConstIterator desc = (*es)->getDescriptors()->begin();
 186                                                         desc != (*es)->getDescriptors()->end(); ++desc)
 187                                         {
 188                                                 switch ((*desc)->getTag())
 189                                                 {
 190                                                 case ISO_639_LANGUAGE_DESCRIPTOR:
 191                                                 {
 192                                                         const Iso639LanguageList *languages = ((Iso639LanguageDescriptor*)*desc)->getIso639Languages();
 193
 194                                                                 /* use last language code */
 195                                                         for (Iso639LanguageConstIterator i(languages->begin()); i != languages->end(); ++i)
 196                                                                 audio.language_code = (*i)->getIso639LanguageCode();
 197
 198                                                         break;
 199                                                 }
 200                                                 case COMPONENT_DESCRIPTOR:
 201                                                         audio.component_tag = ((ComponentDescriptor*)*desc)->getComponentTag();
 202                                                         break;
 203                                                 }
 204                                         }
 205
 206                                         program.audioStreams.push_back(audio);
 207                                 }
 208                                 if (isvideo)
 209                                         program.videoStreams.push_back(video);
 210                         }
 211                 }
 212                 return 0;
 213         }
 214         else if ( m_service && !m_service->cacheEmpty() )
 215         {
 216                 int vpid = m_service->getCachePID(eDVBService::cVPID),
 217                         apid_ac3 = m_service->getCachePID(eDVBService::cAPID),
 218                         apid_mpeg = m_service->getCachePID(eDVBService::cAC3PID),
 219                         pcrpid = m_service->getCachePID(eDVBService::cPCRPID),
 220                         cnt=0;
 221                 if ( vpid != -1 )
 222                 {
 223                         videoStream s;
 224                         s.pid = vpid;
 225                         program.videoStreams.push_back(s);
 226                         ++cnt;
 227                 }
 228                 if ( apid_ac3 != -1 )
 229                 {
 230                         audioStream s;
 231                         s.type = audioStream::atAC3;
 232                         s.pid = apid_ac3;
 233                         program.audioStreams.push_back(s);
 234                         ++cnt;
 235                 }
 236                 if ( apid_mpeg != -1 )
 237                 {
 238                         audioStream s;
 239                         s.type = audioStream::atMPEG;
 240                         s.pid = apid_mpeg;
 241                         program.audioStreams.push_back(s);
 242                         ++cnt;
 243                 }
 244                 if ( pcrpid != -1 )
 245                 {
 246                         ++cnt;
 247                         program.pcrPid = pcrpid;
 248                 }
 249                 if ( cnt )
 250                         return 0;
 251         }
 252         return -1;
 253 }
 254
 255 int eDVBServicePMTHandler::getChannel(eUsePtr<iDVBChannel> &channel)
 256 {
 257         channel = m_channel;
 258         if (channel)
 259                 return 0;
 260         else
 261                 return -1;
 262 }
 263
 264 int eDVBServicePMTHandler::getDemux(ePtr<iDVBDemux> &demux)
 265 {
 266         demux = m_demux;
 267         if (demux)
 268                 return 0;
 269         else
 270                 return -1;
 271 }
 272
 273 int eDVBServicePMTHandler::getPVRChannel(ePtr<iDVBPVRChannel> &pvr_channel)
 274 {
 275         pvr_channel = m_pvr_channel;
 276         if (pvr_channel)
 277                 return 0;
 278         else
 279                 return -1;
 280 }
 281
 282 int eDVBServicePMTHandler::tune(eServiceReferenceDVB &ref)
 283 {
 284         RESULT res;
 285         m_reference = ref;
 286
 287                 /* is this a normal (non PVR) channel? */
 288         if (ref.path.empty())
 289         {
 290                 eDVBChannelID chid;
 291                 ref.getChannelID(chid);
 292                 res = m_resourceManager->allocateChannel(chid, m_channel);
 293                 eDebug("allocate Channel: res %d", res);
 294         } else
 295         {
 296                 eDVBMetaParser parser;
 297
 298                 if (parser.parseFile(ref.path))
 299                         eWarning("no .meta file found, trying original service ref.");
 300                 else
 301                         m_reference = parser.m_ref;
 302
 303                 eDebug("alloc PVR");
 304                         /* allocate PVR */
 305                 res = m_resourceManager->allocatePVRChannel(m_pvr_channel);
 306                 if (res)
 307                         eDebug("allocatePVRChannel failed!\n");
 308                 m_channel = m_pvr_channel;
 309         }
 310
 311         if (m_channel)
 312         {
 313                 m_channel->connectStateChange(
 314                         slot(*this, &eDVBServicePMTHandler::channelStateChanged),
 315                         m_channelStateChanged_connection);
 316                 m_last_channel_state = -1;
 317                 channelStateChanged(m_channel);
 318         } else
 319         {
 320                 serviceEvent(eventTuneFailed);
 321                 return res;
 322         }
 323
 324         if (m_pvr_channel)
 325                 m_pvr_channel->playFile(ref.path.c_str());
 326
 327         ePtr<iDVBChannelList> db;
 328         if (!m_resourceManager->getChannelList(db))
 329                 db->getService((eServiceReferenceDVB&)m_reference, m_service);
 330
 331         return res;
 332 }
 333
 334 std::map<eServiceReferenceDVB, eDVBCAService*> eDVBCAService::exist;
 335
 336 eDVBCAService::eDVBCAService()
 337         :m_prev_build_hash(0), m_sendstate(0), m_retryTimer(eApp)
 338 {
 339         memset(m_used_demux, 0xFF, sizeof(m_used_demux));
 340         CONNECT(m_retryTimer.timeout, eDVBCAService::sendCAPMT);
 341         Connect();
 342 }
 343
 344 eDVBCAService::~eDVBCAService()
 345 {
 346         eDebug("[eDVBCAService] free service %s", m_service.toString().c_str());
 347         ::close(m_sock);
 348 }
 349
 350 RESULT eDVBCAService::register_service( const eServiceReferenceDVB &ref, int demux_num, eDVBCAService *&caservice )
 351 {
 352         CAServiceMap::iterator it = exist.find(ref);
 353         if ( it != exist.end() )
 354                 caservice = it->second;
 355         else
 356         {
 357                 caservice = (exist[ref]=new eDVBCAService());
 358                 caservice->m_service = ref;
 359                 eDebug("[eDVBCAHandler] new service %s", ref.toString().c_str() );
 360         }
 361 // search free demux entry
 362         int iter=0, max_demux_slots = sizeof(caservice->m_used_demux);
 363
 364         while ( iter < max_demux_slots && caservice->m_used_demux[iter] != 0xFF )
 365                 ++iter;
 366
 367         if ( iter < max_demux_slots )
 368         {
 369                 caservice->m_used_demux[iter] = demux_num & 0xFF;
 370                 eDebug("[eDVBCAHandler] add demux %d to slot %d service %s", demux_num, iter, ref.toString().c_str());
 371         }
 372         else
 373         {
 374                 eDebug("[eDVBCAHandler] no more demux slots free for service %s!!", ref.toString().c_str());
 375                 return -1;
 376         }
 377         return 0;
 378 }
 379
 380 RESULT eDVBCAService::unregister_service( const eServiceReferenceDVB &ref, int demux_num, eTable<ProgramMapSection> *ptr )
 381 {
 382         CAServiceMap::iterator it = exist.find(ref);
 383         if ( it == exist.end() )
 384         {
 385                 eDebug("[eDVBCAHandler] try to unregister non registered %s", ref.toString().c_str());
 386                 return -1;
 387         }
 388         else
 389         {
 390                 eDVBCAService *caservice = it->second;
 391                 bool freed = false;
 392                 int iter = 0,
 393                         used_demux_slots = 0,
 394                         max_demux_slots = sizeof(caservice->m_used_demux)/sizeof(int);
 395                 while ( iter < max_demux_slots )
 396                 {
 397                         if ( caservice->m_used_demux[iter] != 0xFF )
 398                         {
 399                                 if ( !freed && caservice->m_used_demux[iter] == demux_num )
 400                                 {
 401                                         eDebug("[eDVBCAService] free slot %d demux %d for service %s", iter, caservice->m_used_demux[iter], caservice->m_service.toString().c_str() );
 402                                         caservice->m_used_demux[iter] = 0xFF;
 403                                         freed=true;
 404                                 }
 405                                 else
 406                                         ++used_demux_slots;
 407                         }
 408                         ++iter;
 409                 }
 410                 if (!freed)
 411                 {
 412                         eDebug("[eDVBCAService] couldn't free demux slot for demux %d", demux_num);
 413                         return -1;
 414                 }
 415                 if (!used_demux_slots)  // no more used.. so we remove it
 416                 {
 417                         delete it->second;
 418                         exist.erase(it);
 419                 }
 420                 else
 421                 {
 422                         if (ptr)
 423                                 it->second->buildCAPMT(ptr);
 424                         else
 425                                 eDebug("[eDVBCAHandler] can not send updated demux info");
 426                 }
 427         }
 428         return 0;
 429 }
 430
 431 void eDVBCAService::Connect()
 432 {
 433         memset(&m_servaddr, 0, sizeof(struct sockaddr_un));
 434         m_servaddr.sun_family = AF_UNIX;
 435         strcpy(m_servaddr.sun_path, "/tmp/camd.socket");
 436         m_clilen = sizeof(m_servaddr.sun_family) + strlen(m_servaddr.sun_path);
 437         m_sock = socket(PF_UNIX, SOCK_STREAM, 0);
 438         connect(m_sock, (struct sockaddr *) &m_servaddr, m_clilen);
 439         fcntl(m_sock, F_SETFL, O_NONBLOCK);
 440         int val=1;
 441         setsockopt(m_sock, SOL_SOCKET, SO_REUSEADDR, &val, 4);
 442 }
 443
 444 void eDVBCAService::buildCAPMT(eTable<ProgramMapSection> *ptr)
 445 {
 446         if (!ptr)
 447                 return;
 448
 449         eDVBTableSpec table_spec;
 450         ptr->getSpec(table_spec);
 451
 452         int pmtpid = table_spec.pid,
 453                 pmt_version = table_spec.version;
 454
 455         uint8_t demux_mask = 0;
 456         uint8_t first_demux_num = 0xFF;
 457
 458 #if 1
 459         int iter=0, max_demux_slots = sizeof(m_used_demux);
 460         while ( iter < max_demux_slots )
 461         {
 462                 if ( m_used_demux[iter] != 0xFF )
 463                 {
 464                         if ( first_demux_num == 0xFF )
 465                                 first_demux_num = m_used_demux[iter];
 466                         demux_mask |= (1 << m_used_demux[iter]);
 467                 }
 468                 ++iter;
 469         }
 470 #else
 471         demux_mask = 3;
 472         first_demux_num = 0;
 473 #endif
 474
 475         if ( first_demux_num == 0xFF )
 476         {
 477                 eDebug("[eDVBCAService] no demux found for service %s", m_service.toString().c_str() );
 478                 return;
 479         }
 480
 481         eDebug("demux %d mask %02x prevhash %08x", first_demux_num, demux_mask, m_prev_build_hash);
 482
 483         unsigned int build_hash = (pmtpid << 16);
 484         build_hash |= (demux_mask << 8);
 485         build_hash |= (pmt_version&0xFF);
 486
 487         if ( build_hash == m_prev_build_hash )
 488         {
 489                 eDebug("[eDVBCAService] don't build/send the same CA PMT twice");
 490                 return;
 491         }
 492
 493         std::vector<ProgramMapSection*>::const_iterator i=ptr->getSections().begin();
 494         if ( i != ptr->getSections().end() )
 495         {
 496                 CaProgramMapSection capmt(*i++, m_prev_build_hash ? 0x05 /*update*/ : 0x03 /*only*/, 0x01 );
 497
 498                 while( i != ptr->getSections().end() )
 499                 {
 500 //                      eDebug("append");
 501                         capmt.append(*i++);
 502                 }
 503
 504                 // add our private descriptors to capmt
 505                 uint8_t tmp[10];
 506
 507                 tmp[0]=0x84;  // pmt pid
 508                 tmp[1]=0x02;
 509                 tmp[2]=pmtpid>>8;
 510                 tmp[3]=pmtpid&0xFF;
 511                 capmt.injectDescriptor(tmp, false);
 512
 513                 tmp[0] = 0x82; // demux
 514                 tmp[1] = 0x02;
 515                 tmp[2] = demux_mask;    // descramble bitmask
 516                 tmp[3] = first_demux_num; // read section data from demux number
 517                 capmt.injectDescriptor(tmp, false);
 518
 519                 tmp[0] = 0x81; // dvbnamespace
 520                 tmp[1] = 0x08;
 521                 tmp[2] = m_service.getDVBNamespace().get()>>24;
 522                 tmp[3]=(m_service.getDVBNamespace().get()>>16)&0xFF;
 523                 tmp[4]=(m_service.getDVBNamespace().get()>>8)&0xFF;
 524                 tmp[5]=m_service.getDVBNamespace().get()&0xFF;
 525                 tmp[6]=m_service.getTransportStreamID().get()>>8;
 526                 tmp[7]=m_service.getTransportStreamID().get()&0xFF;
 527                 tmp[8]=m_service.getOriginalNetworkID().get()>>8;
 528                 tmp[9]=m_service.getOriginalNetworkID().get()&0xFF;
 529                 capmt.injectDescriptor(tmp, false);
 530
 531                 capmt.writeToBuffer(m_capmt);
 532         }
 533
 534         m_prev_build_hash = build_hash;
 535
 536         if ( m_sendstate != 0xFFFFFFFF )
 537                 m_sendstate=0;
 538         sendCAPMT();
 539 }
 540
 541 void eDVBCAService::sendCAPMT()
 542 {
 543         if ( m_sendstate && m_sendstate != 0xFFFFFFFF ) // broken pipe retry
 544         {
 545                 ::close(m_sock);
 546                 Connect();
 547         }
 548
 549         int wp=0;
 550         if ( m_capmt[3] & 0x80 )
 551         {
 552                 int i=0;
 553                 int lenbytes = m_capmt[3] & ~0x80;
 554                 while(i < lenbytes)
 555                         wp = (wp << 8) | m_capmt[4 + i++];
 556                 wp+=4;
 557                 wp+=lenbytes;
 558         }
 559         else
 560         {
 561                 wp = m_capmt[3];
 562                 wp+=4;
 563         }
 564
 565         if ( write(m_sock, m_capmt, wp) == wp )
 566         {
 567                 m_sendstate=0xFFFFFFFF;
 568                 eDebug("[eDVBCAHandler] send %d bytes",wp);
 569 #if 1
 570                 for(int i=0;i<wp;i++)
 571                         eDebugNoNewLine("%02x ", m_capmt[i]);
 572                 eDebug("");
 573 #endif
 574         }
 575         else
 576         {
 577                 switch(m_sendstate)
 578                 {
 579                         case 0xFFFFFFFF:
 580                                 ++m_sendstate;
 581                                 m_retryTimer.start(0,true);
 582 //                              eDebug("[eDVBCAHandler] send failed .. immediate retry");
 583                                 break;
 584                         default:
 585                                 m_retryTimer.start(5000,true);
 586 //                              eDebug("[eDVBCAHandler] send failed .. retry in 5 sec");
 587                                 break;
 588                 }
 589                 ++m_sendstate;
 590         }
 591 }