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