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