]> git.vomp.tv Git - vompclient-marten.git/blob - demuxer.cc
Add files for debian package generation
[vompclient-marten.git] / 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