demuxer.cc

   1 /*
   2     Copyright 2005-2008 Mark Calderbank
   3     Copyright 2007 Marten Richter (AC3 support)
   4
   5     This file is part of VOMP.
   6
   7     VOMP is free software; you can redistribute it and/or modify
   8     it under the terms of the GNU General Public License as published by
   9     the Free Software Foundation; either version 2 of the License, or
  10     (at your option) any later version.
  11
  12     VOMP is distributed in the hope that it will be useful,
  13     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15     GNU General Public License for more details.
  16
  17     You should have received a copy of the GNU General Public License
  18     along with VOMP; if not, write to the Free Software Foundation, Inc.,
  19     51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  20 */
  21
  22 #include "demuxer.h"
  23
  24 #include "callback.h"
  25 #include "dvbsubtitles.h"
  26 #include "log.h"
  27
  28 #include <cstdlib>
  29
  30 #include <math.h>
  31
  32 #define DEMUXER_SEQ_HEAD 0x000001B3
  33 #define DEMUXER_PIC_HEAD 0x00000101
  34 #define DEMUXER_SEQ_EXT_HEAD 0x000001B5
  35
  36 #define DEMUXER_H264_ACCESS_UNIT 0x00000109
  37 #define DEMUXER_H264_SEQ_PARAMETER_SET 0x00000107
  38 #define DEMUXER_H264_SUB_ENHANCEMENT_INF 0x00000106
  39
  40
  41 #define SEEK_THRESHOLD 150000 // About 1.5 seconds
  42
  43 // Statics
  44 const int Demuxer::FrameRates[9] = { 0, 23, 24, 25, 29, 30, 50, 59, 60 };
  45 Demuxer* Demuxer::instance = NULL;
  46
  47 class NALUUnit {
  48 public:
  49     NALUUnit(const UCHAR* buf,UINT length_buf);
  50     ~NALUUnit();
  51
  52 inline    UINT getBits(UINT num_bits);
  53     UINT getUe();
  54     int getSe();
  55     bool isEonalu() {return eonalu;};
  56
  57 protected:
  58     UCHAR* nalu_buf;
  59     UINT nalu_length;
  60     UINT pos;
  61     UCHAR bit_pos;
  62     UCHAR working_byte;
  63     UINT last_bytes;
  64     bool eonalu;
  65 };
  66
  67 NALUUnit::NALUUnit(const UCHAR *buf, UINT length_buf)
  68 {
  69     nalu_length=0;
  70     nalu_buf=NULL;
  71     pos=0;
  72     bit_pos=0;
  73     working_byte=0;
  74     last_bytes=0;
  75     eonalu=false;
  76
  77     UINT nalu_start=0;
  78     UINT nalu_end=0;
  79     UINT pattern =(((UINT)buf[ 0] << 16) |
  80                    ((UINT)buf[1] <<  8) |
  81                     (UINT)buf[2]  );
  82     nalu_start=3;
  83     while (pattern != 0x000001)
  84     {
  85         if (++nalu_start >= length_buf) return;
  86         pattern = ((pattern << 8) | buf[nalu_start])&0x00FFFFFF;
  87     }
  88     nalu_end=nalu_start+1;
  89     pattern = ((pattern << 8) | buf[nalu_end])&0x00FFFFFF;
  90
  91     while (pattern != 0x000001 && pattern != 0x000000)
  92     {
  93         if (++nalu_end >= length_buf) { nalu_end+=3;break;};
  94         pattern = ((pattern << 8) | buf[nalu_end])&0x00FFFFFF;
  95     }
  96     nalu_end-=3;
  97     nalu_end=min(length_buf-1,nalu_end);
  98     nalu_length=nalu_end-nalu_start;
  99     nalu_buf=(UCHAR*)malloc(nalu_length);
 100     memcpy(nalu_buf,buf+nalu_start,nalu_length);
 101     pos=1;
 102 }
 103
 104 NALUUnit::~NALUUnit()
 105 {
 106     if (nalu_buf) free(nalu_buf);
 107 }
 108
 109 inline UINT NALUUnit::getBits(UINT num_bits)
 110 {
 111     if (num_bits==0) return 0; //???
 112     UINT remain_bits=num_bits;
 113     UINT work=0;
 114     //May be slow, but should work!
 115     while (remain_bits>0) {
 116         if (bit_pos==0) {
 117             if (pos<nalu_length)
 118             {
 119                 last_bytes=(last_bytes<<8) & nalu_buf[pos];
 120                 if ((last_bytes & 0x00FFFFFF) == 0x000003) pos++; //emulation prevention byte
 121                  if (pos<nalu_length)
 122                  {
 123                      working_byte=nalu_buf[pos];
 124                      pos++;
 125                  }
 126                  else
 127                  {
 128                      working_byte=0;
 129                      eonalu=true;
 130                  }
 131             }
 132             else
 133             {
 134                 working_byte=0;
 135                 eonalu=true;
 136             }
 137
 138         }
 139         UINT fetch_bits=min(remain_bits,8-bit_pos);
 140         work=work <<fetch_bits;
 141         //work|=((working_byte>>bit_pos) & (0xFF>>(8-fetch_bits)));
 142         work|=(working_byte &(0xFF>>(bit_pos)))>>(8-fetch_bits-bit_pos);
 143         remain_bits-=fetch_bits;
 144         bit_pos=(bit_pos+fetch_bits)%8;
 145     }
 146     return work;
 147 }
 148
 149 UINT NALUUnit::getUe()
 150 {
 151     int leadbits=-1;
 152     bool bit;
 153     for( bit = 0; !bit && !eonalu; leadbits++ )
 154         bit = getBits(1);
 155     if (eonalu) return true;
 156     return ((1 << leadbits)-1)+getBits(leadbits);
 157 }
 158
 159 int NALUUnit::getSe()
 160 {
 161     UINT input=getUe();
 162     if (input==0) return 0;
 163     int output=((input+1)>>1);
 164     if (input & 0x1) output*=-1;
 165     return output;
 166 }
 167
 168
 169
 170 static const int PESPacket_initial_size = 2000;
 171
 172 // PESPacket methods
 173 PESPacket::PESPacket()
 174 {
 175   data_size = PESPacket_initial_size;
 176   data = (UCHAR*)malloc(data_size);
 177   data[0] = 0x00;
 178   data[1] = 0x00;
 179   data[2] = 0x01;
 180   init(0);
 181 }
 182
 183 PESPacket::PESPacket(const PESPacket& packet)
 184 {
 185   copyFrom(packet);
 186 }
 187
 188 PESPacket& PESPacket::operator=(const PESPacket& packet)
 189 {
 190   if (this != &packet)
 191   {
 192     if (data) free(data);
 193     copyFrom(packet);
 194   }
 195   return *this;
 196 }
 197
 198 PESPacket::~PESPacket()
 199 {
 200   if (data) free(data);
 201 }
 202
 203 void PESPacket::copyFrom(const PESPacket& packet)
 204 {
 205   length = packet.length;
 206   size = packet.size;
 207   packetType = packet.packetType;
 208   substream = packet.substream;
 209   seq_header = packet.seq_header;
 210   data_size = size;
 211   data = (UCHAR*)malloc(data_size);
 212   memcpy(data, packet.data, data_size);
 213 }
 214
 215 void PESPacket::init(UCHAR type, UCHAR sub)
 216 {
 217   length = 0;
 218   size = 6;
 219   data[4] = data[5] = 0;
 220   data[3] = type;
 221   packetType = type;
 222   substream = sub;
 223   seq_header = 1; // Unknown seq_header status
 224
 225 }
 226
 227 void PESPacket::truncate()
 228 {
 229   init(packetType,substream);
 230 }
 231
 232
 233
 234 int PESPacket::write(const UCHAR *buf, int len)
 235 {
 236
 237
 238   if (size + len > 0x10000) return 0;
 239   if (size + len > data_size)
 240   { // Reallocate
 241     UINT new_data_size = max(data_size + data_size / 2, data_size + len);
 242     if (new_data_size > 0x10000) new_data_size = 0x10000;
 243     data_size = new_data_size;
 244     data = (UCHAR*)realloc(data, data_size);
 245   }
 246   memcpy(data + size, buf, len);
 247   length += len;
 248   size += len;
 249   data[4] = (length >> 8);
 250   data[5] = (length & 0xFF);
 251   // We have added data - reset seq_header indicator if necessary
 252   if (seq_header == 0) seq_header = 1; // Reset to 'unknown'
 253   return 1;
 254 }
 255
 256 ULLONG PESPacket::getPTS() const
 257 {
 258   if ( ( (packetType >= Demuxer::PESTYPE_AUD0 &&
 259           packetType <= Demuxer::PESTYPE_AUDMAX)
 260          ||
 261          (packetType >= Demuxer::PESTYPE_VID0 &&
 262           packetType <= Demuxer::PESTYPE_VIDMAX)
 263    ||
 264           packetType == Demuxer::PESTYPE_PRIVATE_1
 265        )
 266        && size >= 14 && data[7] & 0x80)
 267   {
 268     return ( (ULLONG)(data[ 9] & 0x0E) << 29) |
 269            ( (ULLONG)(data[10])        << 22 ) |
 270            ( (ULLONG)(data[11] & 0xFE) << 14 ) |
 271            ( (ULLONG)(data[12])        <<  7 ) |
 272            ( (ULLONG)(data[13] & 0xFE) >>  1 );
 273   }
 274   else return PTS_INVALID;
 275 }
 276
 277 UCHAR PESPacket::operator[] (UINT index) const
 278 {
 279   if (index >= size)
 280     return 0;
 281   else
 282     return data[index];
 283 }
 284
 285 UINT PESPacket::findPictureHeader(bool h264) const
 286 {
 287   if (size < 12) return 0;
 288   UINT pattern = ( ((UINT)data[ 8] << 24) |
 289                    ((UINT)data[ 9] << 16) |
 290                    ((UINT)data[10] <<  8) |
 291                     (UINT)data[11]  );
 292   UINT pos = 11;
 293   if (h264) {
 294
 295           while (pattern != DEMUXER_H264_ACCESS_UNIT)
 296           {
 297                   if (++pos >= size) return 0;
 298                   pattern = (pattern << 8) | data[pos];
 299           }
 300           return pos-3;
 301   } else {
 302           while (pattern != DEMUXER_PIC_HEAD)
 303           {
 304                   if (++pos >= size) return 0;
 305                   pattern = (pattern << 8) | data[pos];
 306           }
 307           return pos-3;
 308   }
 309 }
 310
 311 UINT PESPacket::countPictureHeaders(bool h264) const
 312 {
 313   if (size < 12) return 0;
 314   UINT pattern = ( ((UINT)data[ 8] << 24) |
 315                    ((UINT)data[ 9] << 16) |
 316                    ((UINT)data[10] <<  8) |
 317                     (UINT)data[11]  );
 318   UINT pos = 11;
 319   UINT count=0;
 320   if (h264) {
 321
 322           while (pos<size)
 323           {
 324           pos++;
 325                   pattern = (pattern << 8) | data[pos];
 326           if (pattern==DEMUXER_H264_ACCESS_UNIT) count++;
 327           }
 328           return count;
 329   } else {
 330       while (pos<size)
 331           {
 332           pos++;
 333                   pattern = (pattern << 8) | data[pos];
 334           if (pattern==DEMUXER_PIC_HEAD) count++;
 335           }
 336           return count;
 337   }
 338 }
 339
 340 UINT PESPacket::findSeqHeader(bool h264) const
 341 {
 342   if (seq_header != 1) return seq_header;
 343   if (size < 12) return 0;
 344   UINT pattern = ( ((UINT)data[ 8] << 24) |
 345                    ((UINT)data[ 9] << 16) |
 346                    ((UINT)data[10] <<  8) |
 347                     (UINT)data[11]  );
 348   UINT pos = 11;
 349   if (h264) {
 350       while ((pattern & 0xFFFFFF1F) != DEMUXER_H264_SEQ_PARAMETER_SET)
 351           {
 352                   if (++pos >= size)
 353                   {
 354                           seq_header = 0;
 355                           return 0;
 356                   }
 357                   pattern = (pattern << 8) | data[pos];
 358           }
 359           seq_header = pos - 3;
 360   }
 361   else
 362   {
 363           while (pattern != DEMUXER_SEQ_HEAD)
 364           {
 365                   if (++pos >= size)
 366                   {
 367                           seq_header = 0;
 368                           return 0;
 369                   }
 370                   pattern = (pattern << 8) | data[pos];
 371           }
 372           seq_header = pos - 3;
 373   }
 374   return seq_header;
 375 }
 376
 377 UINT PESPacket::findSeqExtHeader(bool h264) const
 378 {
 379   if (seq_header != 1) return seq_header;
 380   if (size < 12) return 0;
 381   UINT pattern = ( ((UINT)data[ 8] << 24) |
 382                    ((UINT)data[ 9] << 16) |
 383                    ((UINT)data[10] <<  8) |
 384                     (UINT)data[11]  );
 385   UINT pos = 11;
 386   if (h264) {
 387       while ((pattern & 0xFFFFFF1F) != DEMUXER_H264_SUB_ENHANCEMENT_INF)
 388           {
 389                   if (++pos >= size)
 390                   {
 391                           seq_header = 0;
 392                           return 0;
 393                   }
 394                   pattern = (pattern << 8) | data[pos];
 395           }
 396           seq_header = pos - 3;
 397   }
 398   else
 399   {
 400           while (pattern != DEMUXER_SEQ_EXT_HEAD && (data[pos+1]&0xf0)!=0x10)
 401           {
 402                   if (++pos >= (size-1))
 403                   {
 404                           seq_header = 0;
 405                           return 0;
 406                   }
 407                   pattern = (pattern << 8) | data[pos];
 408           }
 409           seq_header = pos - 3;
 410   }
 411   return seq_header;
 412 }
 413
 414 // Demuxer methods
 415 Demuxer::Demuxer()
 416 {
 417   if (instance) return;
 418   instance = this;
 419   initted = false;
 420   callback = NULL;
 421   arcnt = 0;
 422   vid_seeking = aud_seeking = false;
 423   video_pts = audio_pts = 0;
 424   ispre_1_3_19 = false;
 425   packetnum=0;
 426   h264 = false;
 427   fps = 25.0;
 428   astreamtype=4;
 429 }
 430
 431 Demuxer::~Demuxer()
 432 {
 433   shutdown();
 434   instance = NULL;
 435 }
 436
 437 Demuxer* Demuxer::getInstance()
 438 {
 439   return instance;
 440 }
 441
 442 int Demuxer::init(Callback* tcallback, DrainTarget* audio, DrainTarget* video, DrainTarget* teletext,
 443                   ULONG demuxMemoryV, ULONG demuxMemoryA, ULONG demuxMemoryT,double infps, DVBSubtitles* tsubtitles)
 444 {
 445   if (!initted)
 446   {
 447     if ( !videostream.init(video, demuxMemoryV) ||
 448          !audiostream.init(audio, demuxMemoryA) ||
 449          !teletextstream.init(teletext, demuxMemoryT))
 450     {
 451       Log::getInstance()->log("Demuxer", Log::CRIT,
 452                               "Failed to initialize demuxer");
 453       shutdown();
 454       return 0;
 455     }
 456   }
 457   if (teletext) {
 458       isteletextdecoded = true;
 459   } else {
 460       isteletextdecoded = false;
 461   }
 462   fps=infps;
 463   reset();
 464   initted = true;
 465   subtitles = tsubtitles;
 466   callback = tcallback;
 467   return 1;
 468 }
 469
 470 void Demuxer::reset()
 471 {
 472   Log::getInstance()->log("Demuxer", Log::DEBUG, "Reset called");
 473   flush();
 474   video_current = audio_current = teletext_current = subtitle_current = -1;
 475   horizontal_size = vertical_size = 0;
 476   interlaced=true; // default is true
 477   aspect_ratio = (enum AspectRatio) 0;
 478   frame_rate = bit_rate = 0;
 479   ispre_1_3_19 = false;
 480   h264 = false;
 481   packetnum=0;
 482   astreamtype=4;
 483
 484   for (int i = 0; i <= (PESTYPE_AUDMAX - PESTYPE_AUD0); i++)
 485   {
 486     avail_mpaudchan[i] = false;
 487   }
 488   for (int i = 0; i <= (PESTYPE_SUBSTREAM_AC3MAX - PESTYPE_SUBSTREAM_AC30); i++)
 489   {
 490     avail_ac3audchan[i] = false;
 491   }
 492   for (int i = 0; i <= (PESTYPE_SUBSTREAM_DVBSUBTITLEMAX - PESTYPE_SUBSTREAM_DVBSUBTITLE0); i++)
 493   {
 494     avail_dvbsubtitlechan[i] = false;
 495   }
 496 }
 497
 498 int Demuxer::shutdown()
 499 {
 500   videostream.shutdown();
 501   audiostream.shutdown();
 502   teletextstream.shutdown();
 503   initted = false;
 504   return 1;
 505 }
 506
 507 void Demuxer::flush()
 508 {
 509   Log::getInstance()->log("Demuxer", Log::DEBUG, "Flush called");
 510
 511   videostream.flush();
 512   audiostream.flush();
 513   teletextstream.flush();
 514 }
 515
 516 void Demuxer::flushAudio()
 517 {
 518   audiostream.flush();
 519 }
 520
 521 void Demuxer::seek()
 522 {
 523   vid_seeking = aud_seeking = true;
 524   video_pts = audio_pts = teletext_pts = 0;
 525 }
 526
 527 void Demuxer::setAudioStream(int id)
 528 {
 529   audio_current = id;
 530 }
 531
 532 void Demuxer::setVideoStream(int id)
 533 {
 534   video_current = id;
 535 }
 536
 537 void Demuxer::setTeletextStream(int id)
 538 {
 539   teletext_current = id;
 540 }
 541
 542 void Demuxer::setDVBSubtitleStream(int id)
 543 {
 544   subtitle_current = id;
 545 }
 546
 547 void Demuxer::setAspectRatio(enum AspectRatio ar)
 548 {
 549   if (aspect_ratio != ar)
 550   {
 551     Log::getInstance()->log("Demux", Log::DEBUG,
 552                             "Aspect ratio difference signalled");
 553     if (++arcnt > 3) // avoid changing aspect ratio if glitch in signal
 554     {
 555       arcnt = 0;
 556       aspect_ratio = ar;
 557       if (callback) callback->call(this);
 558     }
 559   }
 560   else
 561     arcnt = 0;
 562 }
 563
 564 bool Demuxer::writeAudio(bool * dataavail)
 565 {
 566   return audiostream.drain(dataavail);
 567 }
 568
 569 bool Demuxer::writeVideo(bool * dataavail)
 570 {
 571   return videostream.drain(dataavail);
 572 }
 573
 574 bool Demuxer::writeTeletext(bool * dataavail)
 575 {
 576    return teletextstream.drain(dataavail);
 577 }
 578
 579 bool Demuxer::submitPacket(PESPacket& packet)
 580 {
 581   UINT sent = 0;
 582   UCHAR packet_type = packet.getPacketType();
 583   const UCHAR* packetdata = packet.getData();
 584   if (packet_type >= PESTYPE_VID0 && packet_type <= PESTYPE_VIDMAX)
 585   {
 586     if (video_current == -1) video_current = packet_type;
 587     if (video_current == packet_type && !vid_seeking)
 588         {
 589         sent = videostream.put(&packetdata[0], packet.getSize(), h264?MPTYPE_VIDEO_H264:MPTYPE_VIDEO_MPEG2,packetnum);
 590         if (sent) packetnum++;
 591         }
 592         else
 593       sent = packet.getSize();
 594   }
 595   else if (packet_type >= PESTYPE_AUD0 && packet_type <= PESTYPE_AUDMAX)
 596   {
 597
 598     if (audio_current == -1) audio_current = packet_type;
 599     avail_mpaudchan[packet_type - PESTYPE_AUD0] = true;
 600     if (audio_current == packet_type && !aud_seeking)
 601         {
 602       UCHAR type=MPTYPE_MPEG_AUDIO;
 603       switch (astreamtype)
 604       {
 605       case 3:
 606       case 4:
 607           type=MPTYPE_MPEG_AUDIO; break;
 608       case 0x11:
 609           type=MPTYPE_AAC_LATM; break;
 610       };
 611       sent = audiostream.put(&packetdata[0], packet.getSize(), type,packetnum);
 612           if (sent)  packetnum++;
 613         }
 614         else
 615       sent = packet.getSize();
 616   }
 617   else if (packet_type == PESTYPE_PRIVATE_1 &&
 618            packet.getSubstream() >= PESTYPE_SUBSTREAM_AC30 &&
 619            packet.getSubstream() <= PESTYPE_SUBSTREAM_AC3MAX)
 620   {
 621     avail_ac3audchan[packet.getSubstream() - PESTYPE_SUBSTREAM_AC30] = true;
 622     if (packet.getSubstream() == audio_current)
 623     {
 624       sent = audiostream.put(&packetdata[0], packet.getSize(), (ispre_1_3_19)? MPTYPE_AC3_PRE13 : MPTYPE_AC3,packetnum);
 625           if (sent) packetnum++;
 626     }
 627     else
 628     {
 629       sent = packet.getSize();
 630     }
 631   }
 632   else if (packet_type == PESTYPE_PRIVATE_1 &&
 633            packet.getSubstream() >= PESTYPE_SUBSTREAM_DVBSUBTITLE0 &&
 634            packet.getSubstream() <= PESTYPE_SUBSTREAM_DVBSUBTITLEMAX)
 635   {
 636     avail_dvbsubtitlechan[packet.getSubstream()-PESTYPE_SUBSTREAM_DVBSUBTITLE0]=true;
 637     if (subtitle_current == -1) subtitle_current = packet.getSubstream();
 638     if (subtitles && packet.getSubstream()==subtitle_current)
 639     {
 640          subtitles->put(packet);
 641     }
 642     sent = packet.getSize();
 643   }
 644   else if (isteletextdecoded  && packet_type == PESTYPE_PRIVATE_1 &&
 645            packet.getSubstream() >= PESTYPE_SUBSTREAM_TELETEXT0 &&
 646            packet.getSubstream() <= PESTYPE_SUBSTREAM_TELETEXTMAX)
 647   {
 648
 649     if (teletext_current == -1) teletext_current = packet.getSubstream();
 650     if (teletext_current == packet.getSubstream())
 651     {
 652         sent = teletextstream.put(&packetdata[0], packet.getSize(), MPTYPE_TELETEXT,packetnum);
 653     }
 654     else
 655     {
 656         sent = packet.getSize();
 657     }
 658   }
 659   else
 660   {
 661     sent = packet.getSize();
 662   }
 663
 664   if (sent < packet.getSize()) // Stream is full.
 665     return false;
 666   else
 667     return true;
 668 }
 669
 670 void Demuxer::parsePacketDetails(PESPacket& packet)
 671 {
 672     if (packet.getPacketType() >= PESTYPE_AUD0 &&
 673         packet.getPacketType() <= PESTYPE_AUDMAX)
 674     {
 675         // Extract audio PTS if it exists
 676         if (packet.hasPTS())
 677         {
 678             audio_pts = packet.getPTS();
 679             // We continue to seek on the audio if the video PTS that we
 680             // are trying to match is ahead of the audio PTS by at most
 681             // SEEK_THRESHOLD. We consider the possibility of PTS wrap.
 682             if (aud_seeking && !vid_seeking &&
 683                 !( (video_pts_seek > audio_pts &&
 684                 video_pts_seek - audio_pts < SEEK_THRESHOLD)
 685                 ||
 686                 (video_pts_seek < audio_pts &&
 687                 video_pts_seek + (1LL<<33) - audio_pts < SEEK_THRESHOLD) ))
 688             {
 689                 aud_seeking = 0;
 690                 Log::getInstance()->log("Demuxer", Log::DEBUG,
 691                     "Leaving  audio sync: Audio PTS = %llu", audio_pts);
 692             }
 693         }
 694     }
 695     else if (packet.getPacketType() == PESTYPE_PRIVATE_1) // Private stream
 696     {
 697         //Inspired by vdr's device.c
 698         int payload_begin = packet[8]+9;
 699         unsigned char substream_id = packet[payload_begin];
 700         unsigned char substream_type = substream_id & 0xF0;
 701         unsigned char substream_index = substream_id & 0x1F;
 702 pre_1_3_19_Recording: //This is for old recordings stuff and live TV
 703         if (ispre_1_3_19)
 704         {
 705                 int old_substream=packet.getSubstream();
 706                 if (old_substream){ //someone else already set it, this is live tv
 707                         substream_id = old_substream;
 708                         substream_type = substream_id & 0xF0;
 709                         substream_index = substream_id & 0x1F;
 710                 } else {
 711                 substream_id = PESTYPE_PRIVATE_1;
 712                 substream_type = 0x80;
 713                 substream_index = 0;
 714                 }
 715
 716         }
 717         switch (substream_type)
 718         {
 719         case 0x20://SPU
 720         case 0x30://SPU
 721             packet.setSubstream(substream_id);
 722             break;
 723         case 0xA0: //LPCM //not supported yet, is there any LPCM transmissio out there?
 724             break;
 725         case 0x80: //ac3, currently only one ac3 track per recording supported
 726             packet.setSubstream(substream_type+substream_index);
 727
 728             // Extract audio PTS if it exists
 729             if (packet.hasPTS())
 730             {
 731                 audio_pts = packet.getPTS();
 732                 // We continue to seek on the audio if the video PTS that we
 733                 // are trying to match is ahead of the audio PTS by at most
 734                 // SEEK_THRESHOLD. We consider the possibility of PTS wrap.
 735                 if (aud_seeking && !vid_seeking &&
 736                     !( (video_pts_seek > audio_pts &&
 737                     video_pts_seek - audio_pts < SEEK_THRESHOLD)
 738                     ||
 739                     (video_pts_seek < audio_pts &&
 740                     video_pts_seek + (1LL<<33) - audio_pts < SEEK_THRESHOLD) ))
 741                 {
 742                     aud_seeking = 0;
 743                     Log::getInstance()->log("Demuxer", Log::DEBUG, "Leaving  audio sync: Audio PTS = %llu", audio_pts);
 744                 }
 745             }
 746             break;
 747         case 0x10: //Teletext Is this correct?
 748             packet.setSubstream(substream_id);
 749             // Extract teletxt PTS if it exists
 750             if (packet.hasPTS())
 751             {
 752                 teletext_pts = packet.getPTS();
 753             }
 754             break;
 755         default:
 756             if (!ispre_1_3_19)
 757             {
 758                 ispre_1_3_19=true; //switching to compat mode and live tv mode
 759                 goto pre_1_3_19_Recording;
 760             }
 761             else
 762             {
 763                 packet.setSubstream(0);
 764             }
 765             break;
 766         }
 767     }
 768     else if (packet.getPacketType() >= PESTYPE_VID0 &&
 769         packet.getPacketType() <= PESTYPE_VIDMAX)
 770     {
 771         // Extract video PTS if it exists
 772         if (packet.hasPTS()) video_pts = packet.getPTS();
 773
 774         // If there is a sequence header, extract information
 775         UINT pos = packet.findSeqHeader(h264);
 776         if (pos > 1)
 777         {
 778             if (!h264) {
 779                 pos += 4;
 780                 if (pos+6 >= packet.getSize()) return;
 781                 horizontal_size = ((int)packet[pos] << 4) | ((int)packet[pos+1] >> 4);
 782
 783                 vertical_size = (((int)packet[pos+1] & 0xf) << 8) | (int)packet[pos+2];
 784
 785                 setAspectRatio((enum AspectRatio)(packet[pos+3] >> 4));
 786                 frame_rate = packet[pos+3] & 0x0f;
 787                 if (frame_rate >= 1 && frame_rate <= 8)
 788                     frame_rate = FrameRates[frame_rate];
 789                 else
 790                     frame_rate = 0;
 791                 bit_rate = ((int)packet[pos+4] << 10) |
 792                     ((int)packet[pos+5] << 2) |
 793                     ((int)packet[pos+6] >> 6);
 794             }
 795             else
 796             {
 797                 /* Chris and Mark I know this is ugly, should we move this to a method  of PESPacket or to NALUUnit what would be better?
 798                 This looks so ugly since the header includes variable length parts and I have to parse through the whole header to get the wanted information*/
 799                 NALUUnit nalu(packet.getData()+pos,packet.getSize()-pos);
 800                 profile=nalu.getBits(8);
 801                 nalu.getBits(8); //constraints
 802                 nalu.getBits(8); //level_idc
 803                 nalu.getUe(); //seq_parameter_set_id
 804                 int chroma=1;
 805                 if (profile==100 || profile==110 || profile==122 || profile==144)
 806                 {
 807                     chroma=nalu.getUe();
 808                     if (chroma==3)
 809                     {
 810                         nalu.getBits(1);
 811                     }
 812                     nalu.getUe(); //bit depth lume
 813                     nalu.getUe(); //bit depth chrome
 814                     nalu.getBits(1);
 815                     if (nalu.getBits(1))
 816                     {
 817                         for (int i=0;i<8;i++){
 818                             if (nalu.getBits(1))
 819                             {
 820                                 if (i<6)
 821                                 {
 822                                     UINT lastscale=8;
 823                                     UINT nextscale=8;
 824                                     for (int j=0;j<16;j++) {
 825                                         if (nextscale!=0) {
 826                                             UINT delta=nalu.getSe();
 827                                             nextscale=(lastscale+delta+256)%256;
 828                                         }
 829                                         lastscale=(nextscale==0)?lastscale:nextscale;
 830                                     }
 831                                 }
 832                                 else
 833                                 {
 834                                     UINT lastscale=8;
 835                                     UINT nextscale=8;
 836                                     for (int j=0;j<64;j++) {
 837                                         if (nextscale!=0) {
 838                                             UINT delta=nalu.getSe();
 839                                             nextscale=(lastscale+delta+256)%256;
 840                                         }
 841                                         lastscale=(nextscale==0)?lastscale:nextscale;
 842                                     }
 843                                 }
 844                             }
 845                         }
 846                     }
 847                 }
 848                 int chromunitx=1;
 849                 int chromunity=1;
 850                 switch (chroma) {
 851                 case 0:
 852                     chromunitx=chromunity=1; break;
 853                 case 1:
 854                     chromunitx=chromunity=2; break;
 855                 case 2:
 856                     chromunitx=2;chromunity=1; break;
 857                 case 3:
 858                     chromunitx=chromunity=1; break;
 859                 };
 860
 861                 nalu.getUe(); //log2framenum
 862                 UINT temp=nalu.getUe();
 863                 if (temp==0) //pict order
 864                     nalu.getUe();
 865                 else if (temp==1) {
 866                     nalu.getBits(1);
 867                     nalu.getSe();
 868                     nalu.getSe();
 869                     UINT temp2=nalu.getUe();
 870                     for (int i=0;i<temp2;i++)
 871                         nalu.getSe();
 872                 }
 873                 nalu.getUe(); //Num refframes
 874                 nalu.getBits(1);
 875                 horizontal_size=(nalu.getUe()+1)*16;
 876
 877                 vertical_size=(nalu.getUe()+1)*16;
 878                 int tinterlaced=nalu.getBits(1);
 879                 vertical_size*=(2-tinterlaced);
 880                 interlaced=!tinterlaced;
 881
 882                 if (!tinterlaced) nalu.getBits(1);
 883                 nalu.getBits(1);
 884                 if (nalu.getBits(1))
 885                 {
 886                     horizontal_size-=nalu.getUe()*chromunitx;
 887                     horizontal_size-=nalu.getUe()*chromunitx;
 888                     vertical_size-=nalu.getUe()*(2-tinterlaced)*chromunity;
 889                     vertical_size-=nalu.getUe()*(2-tinterlaced)*chromunity;
 890                 }
 891                 if (nalu.getBits(1))
 892                 {
 893                     if (nalu.getBits(1))
 894                     {
 895                         UINT aspectratioidc=nalu.getBits(8);
 896                         bool hasaspect=false;
 897                         const float aspects[]={1., 1./1.,12./11.,10./11.,16./11.,40./33.,
 898                             24./11.,20./11.,32./11.,80./33.,18./11.,15./11.,64./33.,160./99.,4./3.,3./2.,2./1.};
 899
 900                         float aspectratio=((float) horizontal_size)/((float) vertical_size);
 901                         if (aspectratioidc<=16)
 902                         {
 903                             hasaspect=true;
 904                             aspectratio*=aspects[aspectratioidc];
 905
 906                         }
 907                         else if (aspectratioidc==255)
 908                         {
 909                             int t_sar_width=nalu.getBits(16);
 910                             int t_sar_height=nalu.getBits(16);
 911                             if (t_sar_width!=0 && t_sar_height!=0)
 912                             {
 913                                 hasaspect=true;
 914                                 aspectratio*=((float)t_sar_width)/((float)t_sar_height);
 915                             }
 916                         }
 917                         if (hasaspect)
 918                         {
 919                             if (fabs(aspectratio-16./9.)<0.1) setAspectRatio(ASPECT_16_9);
 920                             else if (fabs(aspectratio-4./3.)<0.1) setAspectRatio(ASPECT_4_3);
 921                         }
 922                     }
 923
 924                 }
 925
 926             }
 927             UINT posext = packet.findSeqExtHeader(h264);
 928             if (posext>1) {
 929                 if (!h264) {
 930                         interlaced=!(packet[pos+1] & 0x08); //really simple
 931                         // if more than full hd is coming we need to add additional parsers here
 932                 } else {
 933                 /*      NALUUnit nalu(packet.getData()+posext,packet.getSize()-posext);
 934                         while (!nalu.isEonalu()) {
 935                                 unsigned int payloadtype=0;
 936                                 unsigned int payloadadd=0xFF;
 937                                 while (payloadadd==0xFF && !nalu.isEonalu()) {
 938                                         payloadadd=nalu.getBits(8);
 939                                         payloadtype+=payloadadd;
 940                                 }
 941                                 unsigned int payloadsize=0;
 942                                 payloadadd=0xff;
 943                                 while (payloadadd==0xFF && !nalu.isEonalu()) {
 944                                        payloadadd=nalu.getBits(8);
 945                                        payloadsize+=payloadadd;
 946                             }
 947                                 switch (payloadtype) {
 948                                 case 1: { // picture timing SEI
 949
 950                                 } break;
 951                                 default: {
 952                                         while (payloadsize) { // not handled skip
 953                                                 nalu.getBits(8);
 954                                                 payloadsize--;
 955                                         }
 956                                 } break;
 957                                 }
 958
 959
 960
 961                         }*/
 962
 963
 964                 }
 965             }
 966
 967             if (vid_seeking)
 968             {
 969                 vid_seeking = 0;
 970                 video_pts_seek = video_pts;
 971                 Log::getInstance()->log("Demuxer", Log::DEBUG,
 972                     "Entering audio sync: Video PTS = %llu", video_pts);
 973                 Log::getInstance()->log("Demuxer", Log::DEBUG,
 974                     "Entering audio sync: Audio PTS = %llu", audio_pts);
 975             }
 976             return;
 977         }
 978     }
 979 }
 980
 981 UINT Demuxer::stripAudio(UCHAR* buf, UINT len)
 982 {
 983   UINT read_pos = 0, write_pos = 0;
 984   UINT pattern, packet_length;
 985   if (len < 4) return 0;
 986   pattern = (buf[0] << 16) | (buf[1] << 8) | (buf[2]);
 987   while (read_pos + 7 <= len)
 988   {
 989     pattern = ((pattern & 0xFFFFFF) << 8) | buf[read_pos+3];
 990     if (pattern < (0x100|PESTYPE_VID0) || pattern > (0x100|PESTYPE_VIDMAX))
 991       read_pos++;
 992     else
 993     {
 994       packet_length = ((buf[read_pos+4] << 8) | (buf[read_pos+5])) + 6;
 995       if (read_pos + packet_length > len)
 996         read_pos = len;
 997       else
 998       {
 999         if (read_pos != write_pos)
1000           memmove(buf+write_pos, buf+read_pos, packet_length);
1001         read_pos += packet_length;
1002         write_pos += packet_length;
1003         pattern = (buf[read_pos] << 16) | (buf[read_pos+1] << 8)
1004                                         | (buf[read_pos+2]);
1005       }
1006     }
1007   }
1008   return write_pos;
1009 }
1010
1011 void Demuxer::changeTimes(UCHAR* buf, UINT len,UINT playtime)
1012 {
1013         UINT pattern, packet_length;
1014         UINT read_pos = 0;
1015         if (len < 4) return;
1016         pattern = (buf[0] << 16) | (buf[1] << 8) | (buf[2]);
1017         while (read_pos + 7 <= len)
1018         {
1019            pattern = ((pattern & 0xFFFFFF) << 8) | buf[read_pos+3];
1020            if (pattern < (0x100|PESTYPE_VID0) || pattern > (0x100|PESTYPE_VIDMAX))
1021               read_pos++;
1022            else
1023            {
1024               packet_length = ((buf[read_pos+4] << 8) | (buf[read_pos+5])) + 6;
1025               // ok we have a packet figure out if pts and dts are present and replace them
1026               if (read_pos + 19 > len) return;
1027               ULLONG new_ts=playtime*90; //play time is on ms so multiply it by 90
1028               if (buf[read_pos+7] & 0x80) { // pts is here, replace it
1029                   buf[read_pos+9]=0x21 | (( new_ts>>29)& 0xde );
1030                   buf[read_pos+10]=0x00 |(( new_ts>>22)& 0xff );
1031                   buf[read_pos+11]=0x01 | (( new_ts>>14)& 0xfe );
1032                   buf[read_pos+12]=0x00 | (( new_ts>>7)& 0xff );
1033                   buf[read_pos+13]=0x01 | (( new_ts<<1)& 0xfe );
1034               }
1035
1036               if (buf[read_pos+7] & 0x40) { // pts is here, replace it
1037                    buf[read_pos+14]=0x21 | (( new_ts>>29)& 0xde );
1038                    buf[read_pos+15]=0x00 | (( new_ts>>22)& 0xff );
1039                    buf[read_pos+16]=0x01 | (( new_ts>>14)& 0xfe );
1040                    buf[read_pos+17]=0x00 | (( new_ts>>7)& 0xff );
1041                    buf[read_pos+18]=0x01 | (( new_ts<<1)& 0xfe );
1042               }
1043               read_pos += packet_length;
1044               pattern = (buf[read_pos] << 16) | (buf[read_pos+1] << 8)
1045                                                 | (buf[read_pos+2]);
1046               }
1047           }
1048
1049 }
1050
1051 bool Demuxer::scanForVideo(UCHAR* buf, UINT len, bool &ish264)
1052 {
1053   UINT pos = 3;
1054   UINT pattern;
1055   ish264=false;
1056   if (len < 4) return false;
1057   pattern = (buf[0] << 16) | (buf[1] << 8) | (buf[2]);
1058   while (pos < len)
1059   {
1060     pattern = ((pattern & 0xFFFFFF) << 8) | buf[pos++];
1061     if (pattern >= (0x100|PESTYPE_VID0) && pattern <= (0x100|PESTYPE_VIDMAX))
1062       return true;
1063   }
1064   return false;
1065 }
1066
1067 bool* Demuxer::getmpAudioChannels()
1068 {
1069   return avail_mpaudchan;
1070 }
1071
1072 bool* Demuxer::getac3AudioChannels()
1073 {
1074   return avail_ac3audchan;
1075 }
1076
1077 bool* Demuxer::getSubtitleChannels()
1078 {
1079   return avail_dvbsubtitlechan;
1080 }
1081
1082 int Demuxer::getselSubtitleChannel()
1083 {
1084   return subtitle_current;
1085 }
1086
1087 int Demuxer::getselAudioChannel()
1088 {
1089   return audio_current;
1090 }
1091
1092