demuxerts.cc

   1 /*
   2     Copyright 2006-2008 Mark Calderbank
   3
   4     This file is part of VOMP.
   5
   6     VOMP is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     VOMP is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with VOMP; if not, write to the Free Software Foundation, Inc.,
  18     51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  19 */
  20
  21 #include "demuxerts.h"
  22 #include "log.h"
  23 #include "video.h"
  24 #include "vdr.h"
  25
  26 #define PTS_JUMP_MARGIN   10000
  27 #define PTS_ALLOWANCE 90000
  28
  29 // TODO: PTS class to handle wrapping arithmetic & comparisons?
  30 static ULLONG PTSDistance(ULLONG pts1, ULLONG pts2)
  31 {
  32   // Assume pts1, pts2 < 2^33; calculate shortest distance between
  33   ULLONG ret = (pts1 > pts2) ? pts1 - pts2 : pts2 - pts1;
  34   if (ret > (1LL<<32)) ret = (1LL<<33) - ret;
  35   return ret;
  36 }
  37
  38 static ULLONG PTSDifference(ULLONG pts1, ULLONG pts2)
  39 {
  40   // Assume pts1, pts2 < 2^33; calculate pts1 - pts2
  41   if (pts1 > pts2)
  42     return pts1 - pts2;
  43   else
  44     return (1LL<<33) + pts1 - pts2;
  45 }
  46
  47 DemuxerTS::DemuxerTS(int p_vID, int p_aID, int p_subID, int p_tID)
  48 {
  49   vID = p_vID; vActive = false;
  50   aID = p_aID; aActive = false;
  51   subID = p_subID; subActive = false;
  52   atype = 0;
  53   subLength = 0;
  54   tID = p_tID;
  55   havechannelinfo=false;
  56 }
  57
  58 void DemuxerTS::flush()
  59 {
  60   partPacket = 0;
  61   parsed = false;
  62   havechannelinfo=false;
  63   Demuxer::flush();
  64   vPacket.init(PESTYPE_VID0);
  65   switch (atype)
  66   {
  67   case 1:
  68     aPacket.init(PESTYPE_PRIVATE_1, PESTYPE_SUBSTREAM_AC30);
  69     break;
  70   default:
  71   case 0:
  72     aPacket.init(PESTYPE_AUD0);
  73     break;
  74   }
  75   subPacket.init(PESTYPE_PRIVATE_1);
  76 tPacket.init(PESTYPE_PRIVATE_1,PESTYPE_SUBSTREAM_TELETEXTMAX);
  77
  78   vActive = false;
  79   aActive = false;
  80   subActive = false;
  81   subLength = 0;
  82   tActive = false;
  83 }
  84
  85 int DemuxerTS::scan(UCHAR *buf, int len)
  86 {
  87   switch (atype)
  88   {
  89   case 1:
  90     return PESTYPE_PRIVATE_1;
  91   default:
  92   case 0:
  93     return PESTYPE_AUD0;
  94   }
  95 }
  96
  97 void DemuxerTS::setVID(int p_vID)
  98 {
  99   vID = p_vID;
 100   vPacket.init(PESTYPE_VID0);
 101   vActive = false;
 102 }
 103
 104 void DemuxerTS::setAID(int p_aID, int type)
 105 {
 106   aID = p_aID;
 107   atype = type;
 108   switch (atype)
 109   {
 110   case 1:
 111     aPacket.init(PESTYPE_PRIVATE_1, PESTYPE_SUBSTREAM_AC30);
 112     setAudioStream(PESTYPE_SUBSTREAM_AC30);
 113     break;
 114   default:
 115   case 0:
 116     aPacket.init(PESTYPE_AUD0);
 117     setAudioStream(PESTYPE_AUD0);
 118     break;
 119   }
 120   aActive = false;
 121 }
 122
 123 void DemuxerTS::setSubID(int p_subID)
 124 {
 125   subID = p_subID;
 126   subPacket.init(PESTYPE_PRIVATE_1);
 127   subActive = false;
 128   subLength = 0;
 129 }
 130
 131 void DemuxerTS::setTID(int p_tID)
 132 {
 133   tID = p_tID;
 134   tPacket.init(PESTYPE_PRIVATE_1,PESTYPE_SUBSTREAM_TELETEXTMAX);
 135   tActive = false;
 136
 137 }
 138
 139
 140
 141
 142 int DemuxerTS::findPTS(UCHAR* buf, int len, ULLONG* dest)
 143 {
 144   int scanaid=0;
 145
 146   while (len >= TS_SIZE)
 147   {
 148       if (*buf != TS_SIG) {buf++;len--; continue;}
 149
 150     //Pattern scanning won't work for ts
 151
 152
 153       int datalen = TS_SIZE - 4;
 154       int pid = ( (buf[1] & 0x1F) << 8 ) | buf[2];
 155       UCHAR payload = buf[1] & 0x40;
 156
 157       if (buf[3] & 0x20) // Adaptation field is present
 158           datalen -= (buf[4] + 1);
 159
 160       UCHAR* curbuf =buf+ (TS_SIZE - datalen);
 161
 162
 163       if (payload) {
 164           if (pid == 0x00) {//PAT, only take first program number, ignore the rest
 165               int pmtpid = (*(curbuf+11)<< 8) | *(curbuf+12);
 166               if ((pmtpid >> 13) != 0x07)
 167               {
 168                   Log::getInstance()->log("findPTS", Log::DEBUG, "PMTPID=%02x %02x TRAILING 111 not set but %x", *(curbuf+11),*(curbuf+12), (pmtpid >> 13));
 169               }
 170               else
 171               {
 172                   pmtpid = pmtpid & 0x1FFF; //clear upper 3 bits
 173                   PMTPID = pmtpid;
 174               }
 175
 176           } else if (pid == PMTPID) { //PMT
 177               int sectionlength = ((*(curbuf+2) << 8) & 0x0F ) | *(buf+3);
 178               //sectionlength += 4; //include header but subtract crc in the end...
 179               int p = 13; //skip fixed part of pmt
 180               while ( p < sectionlength) {
 181                   int streamtype = *(curbuf+p);
 182                   p++;
 183                   int foundpid = (*(curbuf+p)<< 8) | *(curbuf+p+1);
 184                   p += 2; //skip ES Pid
 185                   int eslength = ((*(curbuf+p) << 8) & 0x0F ) | *(curbuf+p+1);
 186                   p += 2; //skip ES length
 187                   if ((foundpid >> 13) != 0x07)
 188                   {
 189                       Log::getInstance()->log("findPTS", Log::DEBUG, "FOUNDPID=%02x %02x TRAILING 111 not set but %x", *(buf+p),*(buf+p+1), (foundpid >> 13));
 190                   }
 191                   else
 192                   {
 193                       foundpid = foundpid & 0x1FFF; //clear upper 3 bits
 194                       int pos=0;
 195                       if (streamtype==3 || streamtype ==4) {
 196                           scanaid=foundpid;
 197                       }
 198                   }
 199                   p += eslength; //skip es descriptor
 200               }
 201           } else if (pid == scanaid) {
 202               UINT framelength = ((UINT)curbuf[4] << 8) | curbuf[5];
 203
 204               if ( curbuf[7] & 0x80 ) // PTS_DTS_flags indicate that PTS is present
 205               {
 206                   *dest = ( (ULLONG)(curbuf[9] & 0x0E) << 29 ) |
 207                   ( (ULLONG)(curbuf[10])        << 22 ) |
 208                   ( (ULLONG)(curbuf[11] & 0xFE) << 14 ) |
 209                   ( (ULLONG)(curbuf[12])        <<  7 ) |
 210                   ( (ULLONG)(curbuf[13] & 0xFE) >>  1 );
 211                   return 1;
 212               }
 213           }
 214       }
 215       len-=TS_SIZE;
 216       buf+=TS_SIZE;
 217   }
 218   // No PTS found.
 219   return 0;
 220 }
 221
 222 void DemuxerTS::setFrameNum(ULONG frame)
 223 {
 224   frameCounting = true;
 225   frameNumber = frame;
 226   Log::getInstance()->log("DemuxerTS", Log::DEBUG, "setFrameNum %d", frame);
 227 }
 228
 229 void DemuxerTS::setPacketNum(ULONG npacket)
 230 {
 231   packetCounting = true;
 232   packetNumber = npacket;
 233   Log::getInstance()->log("DemuxerTS", Log::DEBUG, "setPacketNum %d", npacket);
 234 }
 235
 236
 237 int DemuxerTS::put(UCHAR* buf, int len)
 238 {
 239   int ret = 0;    // return number of bytes consumed
 240
 241   while (partPacket)
 242   {
 243     if (len >= TS_SIZE + 1 - partPacket)
 244     { // Remainder of partial packet is available, plus one
 245       memcpy(store+partPacket, buf, TS_SIZE - partPacket);
 246       ret += TS_SIZE - partPacket;
 247       buf += TS_SIZE - partPacket;
 248       len -= TS_SIZE - partPacket;
 249       partPacket = TS_SIZE;
 250       if (*buf == TS_SIG)
 251       { // Packet is properly terminated
 252         int rc = processTS(store);
 253         if (rc)
 254           partPacket = 0; // Successfully processed
 255         else
 256           return ret;     // Try again later.
 257       }
 258       else
 259       { // Packet not terminated. Find another candidate, and shift store
 260         Log::getInstance()->log("TS Demuxer", Log::ERR, "TS Misaligned!");
 261         int search = 1;
 262         while (search < partPacket && store[search] != TS_SIG)
 263           search++;
 264         partPacket -= search;
 265         if (partPacket) memcpy(store, store+search, partPacket);
 266       }
 267     }
 268     else
 269     { // Still don't have complete packet. Consume what we do have.
 270       memcpy(store+partPacket, buf, len);
 271       partPacket += len;
 272       ret += len;
 273       return ret;
 274     }
 275   }
 276
 277   // Position ourselves at a candidate TS packet
 278   while (len > 0 && *buf != TS_SIG)
 279   {
 280     Log::getInstance()->log("TS Demuxer", Log::ERR, "TS Misaligned!");
 281     buf++; ret++; len--;
 282   }
 283
 284   while (len)
 285   {
 286     if (len < TS_SIZE + 1)
 287     { // Not enough data. Store what we have.
 288       memcpy(store, buf, len);
 289       partPacket = len;
 290       ret += len;
 291       return ret;
 292     }
 293
 294     if (buf[TS_SIZE] != TS_SIG)
 295     { // Not terminated correctly.
 296       buf++; ret++; len--;
 297       while (len > 0 && *buf != TS_SIG)
 298       {
 299         buf++; ret++; len--;
 300       }
 301     }
 302     else
 303     {
 304       int rc = processTS(buf);
 305       if (rc)
 306       { // Successfully processed
 307         buf += TS_SIZE; ret += TS_SIZE; len -= TS_SIZE;
 308       }
 309       else
 310       { // Processing failed.
 311         return ret;
 312       }
 313     }
 314   }
 315   return ret;
 316 }
 317
 318 int DemuxerTS::processTS(UCHAR* buf)
 319 {
 320   int datalen = TS_SIZE - 4;
 321
 322   int pid = ( (buf[1] & 0x1F) << 8 ) | buf[2];
 323   UCHAR payload = buf[1] & 0x40;
 324
 325   if (buf[3] & 0x20) // Adaptation field is present
 326     datalen -= (buf[4] + 1);
 327   if (datalen < 0) // Error in stream TODO log this
 328     return 1;
 329   if (datalen == 0) // Null packet
 330     return 1;
 331   buf += (TS_SIZE - datalen);
 332
 333   if (payload)
 334   {
 335       int rc = 1;
 336       if (pid == 0x00) {//PAT, only take first program number, ignore the rest
 337           int pmtpid = (*(buf+11)<< 8) | *(buf+12);
 338           if ((pmtpid >> 13) != 0x07)
 339           {
 340               Log::getInstance()->log("ProcessTS", Log::DEBUG, "PMTPID=%02x %02x TRAILING 111 not set but %x", *(buf+11),*(buf+12), (pmtpid >> 13));
 341           }
 342           else
 343           {
 344               pmtpid = pmtpid & 0x1FFF; //clear upper 3 bits
 345               PMTPID = pmtpid;
 346           }
 347             return 1;
 348     }
 349     if (pid == PMTPID)
 350     { //PMT
 351         int sectionlength = ((*(buf+2) << 8) & 0x0F ) | *(buf+3);
 352         //sectionlength += 4; //include header but subtract crc in the end...
 353         int p = 13; //skip fixed part of pmt
 354         Channel new_channelinfo;
 355         new_channelinfo.numAPids=0;
 356         new_channelinfo.numDPids=0;
 357         new_channelinfo.numSPids=0;
 358         new_channelinfo.number=0;
 359         new_channelinfo.type=VDR::RADIO;
 360         new_channelinfo.name=NULL;
 361         new_channelinfo.tpid=0xFFFFF; //unused, check this
 362         new_channelinfo.vpid=0xFFFFF; //unused, check this
 363         new_channelinfo.index=NULL;
 364
 365         new_channelinfo.apids.clear();
 366         new_channelinfo.dpids.clear();
 367         new_channelinfo.spids.clear();
 368
 369         while ( p < sectionlength) {
 370             int streamtype = *(buf+p);
 371             p++;
 372             int foundpid = (*(buf+p)<< 8) | *(buf+p+1);
 373             p += 2; //skip ES Pid
 374             int eslength = ((*(buf+p) << 8) & 0x0F ) | *(buf+p+1);
 375             p += 2; //skip ES length
 376             if ((foundpid >> 13) != 0x07)
 377             {
 378               Log::getInstance()->log("ProcessTS", Log::DEBUG, "FOUNDPID=%02x %02x TRAILING 111 not set but %x", *(buf+p),*(buf+p+1), (foundpid >> 13));
 379             }
 380             else
 381             {
 382                 foundpid = foundpid & 0x1FFF; //clear upper 3 bits
 383                 bool notfound=false;
 384                 int pos=0;
 385        //     Log::getInstance()->log("ProcessTS", Log::DEBUG, "FOUNDPID is %x", foundpid);
 386                 switch (streamtype)
 387                 {
 388                  //   case 0x1B: //MPEG 4 for future use
 389                 case 1:
 390                 case 2: { //video
 391                     if (foundpid != getVID())
 392                         setVID(foundpid);
 393                     new_channelinfo.type=VDR::VIDEO;
 394                     new_channelinfo.vpid=foundpid;
 395
 396        //           Log::getInstance()->log("ProcessTS", Log::DEBUG, "Set video PID to %x", foundpid);
 397                         }break;
 398                 case 3:
 399                 case 4: { //audio
 400                     apid newapid;
 401                     newapid.pid = foundpid;
 402                     newapid.name = NULL; //set it in player
 403                     new_channelinfo.apids.push_back(newapid);
 404                     new_channelinfo.numAPids++;
 405                     if (getAID() == 0) { //set unset AID to first audio pid that reports itself
 406                         setAID(foundpid,0);
 407                         Log::getInstance()->log("ProcessTS", Log::DEBUG, "Set audio PID to %x", foundpid);
 408                     }
 409                         } break;
 410                 case 5:
 411                 case 6: { //Private Data
 412                     apid newapid;
 413                     newapid.pid = foundpid;
 414                     newapid.name = NULL; //set it in player
 415                     pos=0;
 416                     notfound=true;
 417
 418                     while (pos< eslength && notfound) {
 419                         switch (buf[p+pos]) {
 420                         case 0x6A: {//Ac3 descriptor
 421                             new_channelinfo.dpids.push_back(newapid);
 422                             new_channelinfo.numDPids++;
 423                             notfound=false;
 424                                    } break;
 425                        case 0x59: {//SubtitlingDescriptor
 426                             new_channelinfo.spids.push_back(newapid);
 427                             new_channelinfo.numSPids++;
 428                             notfound=false;
 429                                    } break;
 430                        case 0x56: {
 431                            new_channelinfo.tpid=foundpid;
 432                            notfound=false;
 433                                   } break;
 434                         };
 435                         pos+=2+buf[p+pos+1];
 436                     }
 437
 438                         } break;
 439                 default://TODO how about subtitles and second audio pids
 440                     break;
 441                 }
 442                 }
 443
 444                  p += eslength; //skip es descriptor
 445
 446
 447             }
 448         bool audioPIDpresent=false; //Check if pids chnages
 449         int i;
 450         for (i=0;i<channelinfo.numAPids;i++) {
 451             if (aID ==channelinfo.apids[i].pid) {
 452                 audioPIDpresent=true;
 453             }
 454         }
 455         for (i=0;i<channelinfo.numDPids && (! audioPIDpresent);i++) {
 456             if (aID ==channelinfo.dpids[i].pid) {
 457                 audioPIDpresent=true;
 458             }
 459         }
 460         if (! audioPIDpresent) {
 461             if (channelinfo.numAPids>0) {
 462                 setAID(channelinfo.apids[0].pid,0);
 463             } else if (channelinfo.numDPids>0) {
 464                 setAID(channelinfo.dpids[0].pid,1);
 465             }
 466         }
 467
 468         channelinfo=new_channelinfo;
 469         havechannelinfo=true;
 470
 471          return 1;
 472     }
 473
 474
 475
 476
 477     if (pid == vID)
 478     {
 479       if (vActive)
 480       {
 481         if (!parsed)
 482         {
 483           parseTSPacketDetails(vPacket);
 484           parsed = true;
 485         }
 486         rc = submitPacket(vPacket);
 487       }
 488       vActive = true;
 489     }
 490     if (pid == aID)
 491     {
 492       if (aActive)
 493       {
 494         if (!parsed)
 495         {
 496           parseTSPacketDetails(aPacket);
 497           parsed = true;
 498         }
 499         rc = submitPacket(aPacket);
 500       }
 501       aActive = true;
 502     }
 503     if (pid == subID)
 504     {
 505       if (subActive)
 506       {
 507         if (!parsed)
 508         {
 509           parseTSPacketDetails(subPacket);
 510           parsed = true;
 511         }
 512         rc = submitPacket(subPacket);
 513       }
 514       subActive = true;
 515     }
 516     if (isteletextdecoded && pid == tID)
 517     {
 518       if (tActive)
 519       {
 520         if (!parsed)
 521         {
 522           parseTSPacketDetails(tPacket);
 523           parsed = true;
 524         }
 525       rc = submitPacket(tPacket);
 526       }
 527       tActive = true;
 528     }
 529     if (rc == 0) return 0;
 530
 531     parsed = false;
 532     if (pid == vID)
 533     {
 534       vPacket.init(PESTYPE_VID0);
 535       buf += 6; datalen -= 6;
 536     }
 537     if (pid == aID)
 538     {
 539       switch (atype)
 540       {
 541       case 1:
 542         aPacket.init(PESTYPE_PRIVATE_1, PESTYPE_SUBSTREAM_AC30);
 543         break;
 544       default:
 545       case 0:
 546         aPacket.init(PESTYPE_AUD0);
 547         break;
 548       }
 549       buf += 6; datalen -= 6;
 550     }
 551     if (pid == subID)
 552     {
 553       subPacket.init(PESTYPE_PRIVATE_1);
 554       subLength = (buf[4] << 8) + buf[5];
 555       buf += 6; datalen -= 6;
 556     }
 557     if (isteletextdecoded && pid == tID)
 558     {
 559         tPacket.init(PESTYPE_PRIVATE_1,PESTYPE_SUBSTREAM_TELETEXTMAX);
 560       buf += 6; datalen -= 6;
 561     }
 562   }
 563
 564   if ( (pid == vID && vActive) ||
 565        (pid == aID && aActive) ||
 566        (pid == tID && tActive) ||
 567        (pid == subID && subActive) )
 568   {
 569     PESPacket* packet = NULL;
 570     if (pid == vID) packet = &vPacket;
 571     if (pid == aID) packet = &aPacket;
 572     if (pid == subID) {
 573       packet = &subPacket;
 574     }
 575     if (pid == tID) packet = &tPacket;
 576     if (packet != NULL)
 577     {
 578       if (packet->write(buf, datalen) == 0)
 579       { // Writing to packet failed. It has overflowed.
 580         if (!parsed)
 581         {
 582           parseTSPacketDetails(*packet);
 583           parsed = true;
 584         }
 585         if (submitPacket(*packet) == 0) return 0;
 586         parsed = false;
 587         packet->truncate();
 588         packet->write((UCHAR*)"\200\000\000", 3);
 589         packet->write(buf, datalen);
 590       }
 591     }
 592   }
 593
 594   if (pid == subID && subActive && subPacket.getLength() == subLength)
 595   {
 596     parsePacketDetails(subPacket);
 597 Log::getInstance()->log("DEMUXERTS", Log::DEBUG, "SUBMITTING A SUBTITLE PACKET %d %x", subLength, subPacket.getSubstream());
 598     submitPacket(subPacket);
 599     subActive = false;
 600   }
 601
 602   return 1;
 603 }
 604
 605 ULONG DemuxerTS::getPacketNum()
 606 {
 607   return packetNumber;
 608 }
 609
 610 ULONG DemuxerTS::getFrameNumFromPTS(ULLONG pts)
 611 {
 612   ULLONG difference = (1LL<<33);
 613   ULONG ref_frame = 0;
 614   int total = 0, actual = 0;
 615   pts_map_mutex.Lock();
 616   PTSMap::iterator iter = pts_map.begin();
 617   while (iter != pts_map.end())
 618   {
 619     ++total;
 620     if (PTSDifference(iter->pts, pts) < PTS_ALLOWANCE)
 621     {
 622       difference = 0;
 623       ref_frame = iter->frame;
 624       actual = total;
 625       break;
 626     }
 627     ULLONG newdiff = PTSDifference(pts, iter->pts);
 628     if (newdiff < difference)
 629     {
 630       difference = newdiff;
 631       ref_frame = iter->frame;
 632       actual = total;
 633     }
 634     ++iter;
 635   }
 636   if (total > 1 && actual == 1) // We are using the most recent PTS ref.
 637   {                             // Delete the rest.
 638     iter = pts_map.begin(); iter++;
 639     pts_map.erase(iter, pts_map.end());
 640   }
 641   pts_map_mutex.Unlock();
 642
 643   if (difference == (1LL<<33))
 644     return 0; // We cannot make sense of the pts
 645   else
 646     return ref_frame + difference * Video::getInstance()->getFPS() / 90000;
 647 }
 648
 649
 650 void DemuxerTS::parseTSPacketDetails(PESPacket packet) // Only important stuff for paket counting reminas
 651 {
 652     parsePacketDetails(packet);
 653     if (packetCounting && packet.getPacketType() >= PESTYPE_AUD0 &&
 654                         packet.getPacketType() <= PESTYPE_AUDMAX)
 655     {
 656         packetNumber++;
 657     }
 658
 659   if (frameCounting && packet.findPictureHeader() &&
 660       packet.getPacketType() >= PESTYPE_VID0 &&
 661       packet.getPacketType() <= PESTYPE_VIDMAX)
 662   {
 663     ULONG frame_num = (frameNumber)++;
 664     if (packet.findSeqHeader() > 1 && packet.hasPTS())
 665     {
 666       PTSMapEntry me;
 667       pts_map_mutex.Lock();
 668       if (pts_map.empty())
 669       {
 670         me.pts = packet.getPTS();
 671         me.frame = frame_num;
 672         pts_map_mutex.Unlock();
 673         pts_map_mutex.Lock();
 674         pts_map.push_front(me);
 675       }
 676       me = pts_map.front();
 677       pts_map_mutex.Unlock();
 678
 679       UINT fps = Video::getInstance()->getFPS();
 680       ULLONG pts_expected = me.pts + 90000*(frame_num - me.frame) / fps;
 681       while (pts_expected > (1LL<<33)) pts_expected -= (1LL<<33);
 682
 683       if (PTSDistance(pts_expected, packet.getPTS()) > PTS_JUMP_MARGIN) // PTS jump!
 684       {
 685         me.pts = packet.getPTS();
 686         me.frame = frame_num;
 687         pts_map_mutex.Lock();
 688         pts_map.push_front(me);
 689         pts_map_mutex.Unlock();
 690       }
 691     }
 692   }
 693 }
 694
 695
 696 bool DemuxerTS::scanForVideo(UCHAR* buf, UINT len)
 697 {
 698     int pmtpidy=0;
 699
 700   while (len >= TS_SIZE)
 701   {
 702       if (*buf != TS_SIG) {buf++;len--; continue;}
 703
 704     //Pattern scanning won't work for ts
 705
 706
 707       int datalen = TS_SIZE - 4;
 708       int pid = ( (buf[1] & 0x1F) << 8 ) | buf[2];
 709       UCHAR payload = buf[1] & 0x40;
 710
 711       if (buf[3] & 0x20) // Adaptation field is present
 712           datalen -= (buf[4] + 1);
 713
 714       UCHAR* curbuf =buf+ (TS_SIZE - datalen);
 715
 716       if (payload) {
 717           if (pid == 0x00) {//PAT, only take first program number, ignore the rest
 718               int pmtpid = (*(curbuf+11)<< 8) | *(curbuf+12);
 719               if ((pmtpid >> 13) != 0x07)
 720               {
 721                   Log::getInstance()->log("findPTS", Log::DEBUG, "PMTPID=%02x %02x TRAILING 111 not set but %x", *(curbuf+11),*(curbuf+12), (pmtpid >> 13));
 722               }
 723               else
 724               {
 725                   pmtpid = pmtpid & 0x1FFF; //clear upper 3 bits
 726                   pmtpidy = pmtpid;
 727               }
 728
 729           } else if (pid == pmtpidy) { //PMT
 730               int sectionlength = ((*(curbuf+2) << 8) & 0x0F ) | *(buf+3);
 731               //sectionlength += 4; //include header but subtract crc in the end...
 732               int p = 13; //skip fixed part of pmt
 733               while ( p < sectionlength) {
 734                   int streamtype = *(curbuf+p);
 735                   p++;
 736                   int foundpid = (*(curbuf+p)<< 8) | *(curbuf+p+1);
 737                   p += 2; //skip ES Pid
 738                   int eslength = ((*(curbuf+p) << 8) & 0x0F ) | *(curbuf+p+1);
 739                   p += 2; //skip ES length
 740                   if ((foundpid >> 13) != 0x07)
 741                   {
 742                       Log::getInstance()->log("findPTS", Log::DEBUG, "FOUNDPID=%02x %02x TRAILING 111 not set but %x", *(buf+p),*(buf+p+1), (foundpid >> 13));
 743                   }
 744                   else
 745                   {
 746                       foundpid = foundpid & 0x1FFF; //clear upper 3 bits
 747                       int pos=0;
 748                       if (streamtype==1 || streamtype ==2) {
 749                           return true;
 750                       }
 751                   }
 752                   p += eslength; //skip es descriptor
 753               }
 754               return false;
 755           }
 756       }
 757       len-=TS_SIZE;
 758       buf+=TS_SIZE;
 759   }
 760   return false;
 761 }
 762
 763 UINT DemuxerTS::stripAudio(UCHAR* buf, UINT len) //it has to be adapted
 764 {
 765     //This function strips all TS Headers and non video payload
 766     UINT readpos=0;
 767     UINT writepos=0;
 768     PESPacket destpaket;
 769     bool started=true;
 770     while (readpos < len ) {
 771         if (buf[readpos] != TS_SIG) {readpos++; continue;}
 772         UINT oldreadpos=readpos;
 773
 774         int datalen = TS_SIZE - 4;
 775         int pid = ( (buf[readpos+1] & 0x1F) << 8 ) | buf[readpos+2];
 776         UCHAR payload = buf[readpos+1] & 0x40;
 777         if (buf[readpos+3] & 0x20) { // Adaptation field is present
 778            datalen -= (buf[readpos+4] + 1);
 779         }
 780         if (datalen < 0) {// Error in stream TODO log this
 781             return 0;
 782         }
 783         if (datalen == 0) {// Null packet
 784              readpos=oldreadpos+TS_SIZE;
 785             continue;
 786         }
 787         readpos += (TS_SIZE - datalen);
 788         UINT towrite=min(datalen,len-readpos);
 789         if (pid == vID) {
 790             if (payload) {
 791                 if (started) {
 792                     parsePacketDetails(destpaket);
 793                     memcpy(buf+writepos,destpaket.getData(),destpaket.getSize());
 794                     writepos+=destpaket.getSize();
 795                  }
 796                  destpaket.init(PESTYPE_VID0);
 797                  readpos += 6; towrite -= 6;
 798                  started=true;
 799             }
 800
 801             if (started) {
 802                 if (!destpaket.write(buf+readpos,towrite)) {
 803                     parsePacketDetails(destpaket);
 804                     memcpy(buf+writepos,destpaket.getData(),destpaket.getSize());
 805                     writepos+=destpaket.getSize();
 806                     destpaket.truncate();
 807                     destpaket.write((UCHAR*)"\200\000\000", 3);
 808                     destpaket.write(buf+readpos,towrite);
 809
 810                 }
 811             }
 812
 813
 814
 815         }
 816         readpos=oldreadpos+TS_SIZE;
 817     }
 818     parsePacketDetails(destpaket);
 819     memcpy(buf+writepos,destpaket.getData(),destpaket.getSize());
 820     writepos+=destpaket.getSize();
 821
 822     return writepos;
 823 }
 824
 825
 826