← Back to branch summary

~ubuntu-branches/ubuntu/breezy/kdemultimedia/breezy

« back to all changes in this revision

Viewing changes to mpeglib/lib/mpegplay/mpegSystemHeader.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Jonathan Riddell
  • Date: 2005-03-24 04:48:58 UTC
  • mfrom: (1.2.1 upstream) (2.1.1 sarge)
  • Revision ID: james.westby@ubuntu.com-20050324044858-8ff88o9jxej6ii3d
Tags: 4:3.4.0-0ubuntu3
Add kubuntu_02_hide_arts_menu_entries.diff to hide artsbuilder and artscontrol k-menu entries

Show diffs side-by-side

added added

removed removed

Lines of Context:
mpeglib/lib/mpegplay/mpegSystemHeader.cpp
13
13
 
14
14
#include "mpegSystemHeader.h"
15
15
 
 
16
#include <iostream>
 
17
 
 
18
using namespace std;
 
19
 
 
20
// we do a fast mod based lookup pid->Map
 
21
#define MAX_PIDS 23
 
22
 
16
23
 
17
24
MpegSystemHeader::MpegSystemHeader() {
18
 
   audioLayerSelect=0;
19
 
   videoLayerSelect=0;
20
 
   lmpeg2=false;
21
 
   lPTSFlag=false;
22
 
 
23
 
   layer=_PACKET_UNKNOWN_LAYER;
24
 
   //
25
 
   //  MPEG2 Stuff [START]
26
 
   //
27
 
 
28
 
   lOriginal=false;
29
 
   lCopyRight=false;
30
 
   lDataAlignmentIndicator=false;
31
 
   lPesPriority=false;
32
 
   lEncrypted=false;
33
 
   startCodePrefix=0;
34
 
 
35
 
   lPTSDTSFlag=false;
36
 
   lESCR=false;
37
 
   lESRateFlag=false;
38
 
   lDMSTRICKFLAG=false;
39
 
   lADDITIONAL_COPY_FLAG=false;
40
 
   lPES_CRC_FLAG=false;
41
 
   lPES_EXT_FLAG=false;
42
 
   nPES_HEADER_DATA_LENGTH=0;
43
 
 
44
 
   // EXT FILED [START]
45
 
 
46
 
   lPrivateDataFlag=false;
47
 
   lPackHeaderFieldFlag=false;
48
 
   lSequenceCounterFlag=false;
49
 
   lSTDBufferFlag=false;
50
 
   lPES_EXT_FLAG_2=false;
51
 
   nPES_EXT_FIELD_LENGTH=0;
52
 
   // EXT FILED [END]
53
 
 
54
 
   subStreamID=0;
55
 
   //
56
 
   // MPEG2 Stuff [END]
57
 
   //
58
 
 
 
25
 
 
26
  packetLen=0;
 
27
  pesPacketLen=0;
 
28
  tsPacketLen=0;
 
29
 
 
30
  
 
31
  audioLayerSelect=0;
 
32
  videoLayerSelect=0;
 
33
  lmpeg2=false;
 
34
  lPTSFlag=false;
 
35
  
 
36
  layer=_PACKET_UNKNOWN_LAYER;
 
37
  lHasPSHeader=false;
 
38
  
 
39
  //
 
40
  //  MPEG2 Stuff [START]
 
41
  //
 
42
  
 
43
  lOriginal=false;
 
44
  lCopyRight=false;
 
45
  lDataAlignmentIndicator=false;
 
46
  lPesPriority=false;
 
47
  lEncrypted=false;
 
48
  startCodePrefix=0;
 
49
  
 
50
  lPTSDTSFlag=false;
 
51
  lESCR=false;
 
52
  lESRateFlag=false;
 
53
  lDMSTRICKFLAG=false;
 
54
  lADDITIONAL_COPY_FLAG=false;
 
55
  lPES_CRC_FLAG=false;
 
56
  lPES_EXT_FLAG=false;
 
57
  nPES_HEADER_DATA_LENGTH=0;
 
58
  
 
59
  // EXT FILED [START]
 
60
  
 
61
  lPrivateDataFlag=false;
 
62
  lPackHeaderFieldFlag=false;
 
63
  lSequenceCounterFlag=false;
 
64
  lSTDBufferFlag=false;
 
65
  lPES_EXT_FLAG_2=false;
 
66
  nPES_EXT_FIELD_LENGTH=0;
 
67
  // EXT FILED [END]
 
68
  
 
69
  subStreamID=0;
 
70
  //
 
71
  // MPEG2 Stuff [END]
 
72
  //
 
73
  
 
74
  // TS Stuff [START]
 
75
  lHasTSHeader=false;
 
76
  programs=0;
 
77
  programNumber=INVALID_PROGRAM;
 
78
  pmtPID=INVALID_PID;
 
79
 
 
80
  mapPidStreamArray=new MapPidStream*[MAX_PIDS];
 
81
  int i;
 
82
  for(i=0;i<MAX_PIDS;i++) {
 
83
    mapPidStreamArray[i]=new MapPidStream();
 
84
    mapPidStreamArray[i]->isValid=false;
 
85
  }
 
86
  currentPos=0;
 
87
  
 
88
 
 
89
  
 
90
  // TS Stuff [END]
59
91
}
60
92
 
61
93
 
62
94
MpegSystemHeader::~MpegSystemHeader() {
63
 
 
 
95
  int i;
 
96
  for(i=0;i<MAX_PIDS;i++) {
 
97
    delete mapPidStreamArray[i];
 
98
  } 
 
99
  delete mapPidStreamArray;
 
100
}
 
101
 
 
102
 
 
103
void MpegSystemHeader::setHeader(unsigned int header) {
 
104
  setPSHeader(header);
 
105
  setTSHeader(header);
 
106
  this->header=header;
 
107
}
 
108
 
 
109
int MpegSystemHeader::hasRAWHeader() {
 
110
  return header==_SEQ_START_CODE;
 
111
}
 
112
 
 
113
 
 
114
unsigned int MpegSystemHeader::getHeader() {
 
115
  return header;
64
116
}
65
117
 
66
118
double MpegSystemHeader::getSCRTimeStamp() {
113
165
  this->layer=layer;
114
166
}
115
167
 
 
168
int MpegSystemHeader::hasPSHeader() {
 
169
  return lHasPSHeader;
 
170
}
 
171
 
 
172
 
116
173
void MpegSystemHeader::addAvailableLayer(int streamID) {
117
174
  switch (streamID>>4){
118
175
  case _PAKET_ID_AUDIO_1>>4:
180
237
  this->packetLen=packetLen;
181
238
}
182
239
 
 
240
 
 
241
int MpegSystemHeader::getPESPacketLen() {
 
242
  return pesPacketLen;
 
243
}
 
244
 
 
245
void MpegSystemHeader::setPESPacketLen(int packetLen) {
 
246
  this->pesPacketLen=packetLen;
 
247
}
 
248
 
 
249
  
 
250
int MpegSystemHeader::getTSPacketLen() {
 
251
  return tsPacketLen;
 
252
}
 
253
 
 
254
 
 
255
void MpegSystemHeader::setTSPacketLen(int packetLen) {
 
256
  this->tsPacketLen=packetLen;
 
257
}
 
258
  
 
259
 
 
260
 
 
261
 
183
262
int MpegSystemHeader::getRate() {
184
263
  return rate;
185
264
}
450
529
//
451
530
 
452
531
 
 
532
//
 
533
// Transport Stream Header [START]
 
534
//
 
535
 
 
536
int MpegSystemHeader:: hasTSHeader() {
 
537
  return lHasTSHeader;
 
538
}
 
539
 
 
540
void MpegSystemHeader::setTSHeader(unsigned int header) { 
 
541
 
 
542
  lHasTSHeader=false;
 
543
 
 
544
  int byte3=header & 0xff;
 
545
  header>>=8;
 
546
  int byte2=header & 0xff;
 
547
  header>>=8;
 
548
  int byte1=header & 0xff;
 
549
  header>>=8;
 
550
  int byte0=header & 0xff;
 
551
 
 
552
 
 
553
  sync_byte=byte0;
 
554
  header=header >> 8;
 
555
  transport_error_indicator = (byte1  >> 7) & 0x01;
 
556
  payload_unit_start_indicator = (byte1 >> 6) & 0x01;
 
557
  transport_priority = (byte1 >> 5) & 0x01;
 
558
  pid = ((byte1 << 8) | byte2) & 0x1fff;
 
559
  transport_scrambling_control = (byte3 >> 6)  & 0x03;
 
560
  adaption_field_control = (byte3 >> 4) & 0x03;
 
561
  continuity_counter  = byte3 & 0x0f;
 
562
 
 
563
  if (sync_byte != 0x47) {
 
564
    return ;
 
565
  }
 
566
  if (transport_error_indicator) {
 
567
    return ;
 
568
  }
 
569
 
 
570
  
 
571
  lHasTSHeader=true;
 
572
 
 
573
}
 
574
 
 
575
unsigned int MpegSystemHeader::getSync_byte() {
 
576
  return  sync_byte;
 
577
}
 
578
 
 
579
 
 
580
unsigned int MpegSystemHeader::getTransport_error_indicator() {
 
581
  return transport_error_indicator;
 
582
}
 
583
 
 
584
 
 
585
unsigned int MpegSystemHeader::getPayload_unit_start_indicator() {
 
586
  return  payload_unit_start_indicator;
 
587
}
 
588
 
 
589
 
 
590
unsigned int MpegSystemHeader::getTransport_priority() {
 
591
  return  transport_priority;
 
592
}
 
593
 
 
594
 
 
595
unsigned int MpegSystemHeader::getPid() {
 
596
  return  pid;
 
597
}
 
598
 
 
599
 
 
600
unsigned int MpegSystemHeader::getTransport_scrambling_control() {
 
601
  return  transport_scrambling_control;
 
602
}
 
603
 
 
604
 
 
605
unsigned int MpegSystemHeader::getAdaption_field_control() {
 
606
  return  adaption_field_control;
 
607
}
 
608
 
 
609
 
 
610
unsigned int MpegSystemHeader::getContinuity_counter() {
 
611
  return  continuity_counter;
 
612
}
 
613
 
 
614
unsigned int MpegSystemHeader::getPrograms() {
 
615
  return programs;
 
616
}
 
617
 
 
618
 
 
619
void MpegSystemHeader::setPrograms(unsigned int programs) {
 
620
  this->programs=programs;
 
621
}
 
622
 
 
623
 
 
624
unsigned int MpegSystemHeader::getProgramNumber() {
 
625
  return programNumber;
 
626
}
 
627
 
 
628
 
 
629
void MpegSystemHeader::setProgramNumber(unsigned int programNumber) {
 
630
  this->programNumber=programNumber;
 
631
}
 
632
 
 
633
 
 
634
unsigned int MpegSystemHeader::getPMTPID() {
 
635
  return pmtPID;
 
636
}
 
637
 
 
638
 
 
639
void MpegSystemHeader::setPMTPID(unsigned int pmtPID) {
 
640
  this->pmtPID=pmtPID;
 
641
}
 
642
 
 
643
 
 
644
MapPidStream* MpegSystemHeader::lookup(unsigned int pid) {
 
645
  return mapPidStreamArray[pid % MAX_PIDS];
 
646
}
 
647
 
 
648
 
 
649
/*
 
650
  Here we do a mapping from the pid to the "meaning" for the
 
651
  pid (defined in the TS spec) and then we map this to
 
652
  a normal mpeg stream ID.
 
653
  (Which is used in the MpegSystemHeder to identify the
 
654
  kind of packet we have)
 
655
*/
 
656
void MpegSystemHeader::insert(unsigned int pid,unsigned int tsType,
 
657
                              MpegSystemHeader* mpegHeader) {
 
658
  if (currentPos >= MAX_PIDS) {
 
659
    cout << "error to much pids in stream.TSSystemStream::insert"<<endl;
 
660
    return;
 
661
  }
 
662
  printf("tsType:%x\n",tsType);
 
663
  switch(tsType) {
 
664
  case ISO_11172_VIDEO:
 
665
  case ISO_13818_VIDEO:
 
666
  case ISO_11172_AUDIO:
 
667
  case ISO_13818_AUDIO:
 
668
  case ISO_13818_PRIVATE:
 
669
  case ISO_13818_PES_PRIVATE:
 
670
  case ISO_13522_MHEG:
 
671
  case ISO_13818_DSMCC:
 
672
  case ISO_13818_TYPE_A:
 
673
  case ISO_13818_TYPE_B:
 
674
  case ISO_13818_TYPE_C:
 
675
  case ISO_13818_TYPE_D:
 
676
  case ISO_13818_TYPE_E:
 
677
  case ISO_13818_AUX:
 
678
    break;
 
679
  default:
 
680
    cout << "ignoring unknown tsType in TSSystemStream::insert"<<endl;
 
681
    return;
 
682
  }
 
683
  
 
684
  MapPidStream* mapPidStream=lookup(pid);
 
685
  int psType=_PAKET_ID_NUKE;
 
686
 
 
687
  mapPidStream->pid=pid;
 
688
  mapPidStream->tsType=tsType;
 
689
  mapPidStream->psType=psType;
 
690
  mapPidStream->isValid=true;
 
691
 
 
692
  currentPos++;
 
693
}
 
694
 
 
695
 
 
696
void MpegSystemHeader::printTSHeader() {
 
697
  if (hasTSHeader() == false) {
 
698
    cout << "MpegSystemHeader::printTSHeader: NO TS HEADER"<<endl;
 
699
    return;
 
700
  }
 
701
 
 
702
  printf("sync:%02X TE:%02X PUS:%02X TP:%02X PID:%04X TSC:%02X "
 
703
         "AFC:%02X CC:%02X\n",
 
704
         sync_byte,
 
705
         transport_error_indicator,
 
706
         payload_unit_start_indicator,
 
707
         transport_priority,
 
708
         pid,
 
709
         transport_scrambling_control,
 
710
         adaption_field_control, 
 
711
         continuity_counter); 
 
712
   
 
713
}
 
714
 
 
715
 
 
716
void MpegSystemHeader::printProgramInfo() {
 
717
  if (programs == 0) {
 
718
    cout << "MpegSystemHeader::printProgramInfo: NO programs"<<endl;
 
719
  } else {
 
720
    cout << "MpegSystemHeader::printProgramInfo: programs:"<<programs<<endl;
 
721
  }
 
722
  printf("MPTS: programNumber=%x pmtPid=%x\n",programNumber, pmtPID);
 
723
 
 
724
}
 
725
 
 
726
void MpegSystemHeader::printMap(MapPidStream* mapPidStream) {
 
727
  if (mapPidStream->isValid == false) {
 
728
    cout << "TSSystemStream::printMap ** INVALID** "<<endl;
 
729
    return;
 
730
  }
 
731
 
 
732
  printf("printMap->isValid:%x\n",mapPidStream->isValid);
 
733
  printf("printMap->pid:%x\n",mapPidStream->pid);
 
734
  printf("printMap->tsType:%x\n",mapPidStream->tsType);
 
735
  printf("printMap->psType:%x\n",mapPidStream->psType);
 
736
  
 
737
}
 
738
 
 
739
 
 
740
//
 
741
// Transport Stream Header [END]
 
742
//
 
743
 
 
744
 
453
745
 
454
746
void MpegSystemHeader::setMPEG2(int lmpeg2) {
455
747
  this->lmpeg2=lmpeg2;
462
754
  cout << "MpegSystemHeader [END]"<<endl;
463
755
  
464
756
}
 
757
 
 
758
 
 
759
void MpegSystemHeader::setPSHeader(unsigned int header) {
 
760
  lHasPSHeader=false;
 
761
  if (header == _PACK_START_CODE) {
 
762
    lHasPSHeader=true;
 
763
  }
 
764
  if (header == _SYSTEM_HEADER_START_CODE) {
 
765
    lHasPSHeader=true;
 
766
  }
 
767
}
 
768
 
 
769
int MpegSystemHeader::isSystemHeader(unsigned int header) {
 
770
 
 
771
  if (header == _PACK_START_CODE) return true;
 
772
  if (header == _SYSTEM_HEADER_START_CODE) return true;
 
773
 
 
774
  int byte3=header & 0xff;
 
775
  header>>=8;
 
776
  int byte2=header & 0xff;
 
777
  header>>=8;
 
778
  int byte1=header & 0xff;
 
779
  header>>=8;
 
780
  int byte0=header & 0xff;
 
781
 
 
782
  if (byte0 != 0x47) return false;
 
783
  if ((byte1  >> 7) & 0x01) return false;
 
784
 
 
785
  return true;
 
786
}