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