开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > DVD > 查看源码
mpeg2demux.cc
资源名称：dvd-munitions.tar.gz　[点击查看]
上传用户：aoeyumen
上传日期：2007-01-06
资源大小：3329k
文件大小：23k
源码类别：

DVD

开发平台：

Unix_Linux

mpeg2demux.cc：源码内容
  1. /*
  2.    File: mpeg2demux.cc
  4.    Description:
  5.    The MPEG 2 demultiplexer class reads MPEG 2 TS, PS and PES data 
  6.    and demultiplexes a Transport Stream or Program Stream in its 
  7.    Packetized Elementary Streams. Elementary Streams are just passed 
  8.    through.
  10.    Created: February 1996, Alex Theo de Jong, NIST
  11. */
  13. #include "athread.hh"
  15. #include <stdio.h>
  16. #include <stdlib.h>
  17. #include <String.h>
  18. #include <fstream.h>
  19. #include <sys/errno.h>
  20. #ifdef IRIX
  21. #include <dmedia/audio.h>
  22. #endif
  23. #ifdef SOLARIS
  24. #include <sys/audioio.h>
  25. #endif
  27. // network stuff 
  28. #include <sys/types.h>
  29. #include <sys/uio.h>
  30. #include <unistd.h>
  31. #include <errno.h>
  33. #include "error.hh"
  34. #include "debug.hh"
  35. #include "util.hh"
  36. #include "sync.hh"
  37. #include "mpeg2const.hh"
  38. #include "mpeg2buff.hh"
  39. #include "mpeg2audio.hh"
  40. #include "mpeg2video.hh"
  41. #include "mpeg2demux.hh"
  42. #include "network.hh"
  44. // Options for Audio and Video player
  46. extern int audio_argc;
  47. extern char** audio_argv;
  48. extern int video_argc;
  49. extern char** video_argv;
  51. extern int time_stamp_qsize;
  52. extern int frame_stamp_qsize;
  53. extern int audio_buffer_size;
  54. extern int video_buffer_size;
  56. // Input socket
  58. extern SocketMulti* sock;
  60. #ifdef TRACE
  61. Mpeg2Buffer* ab=0;
  62. Mpeg2Buffer* vb=0;
  63. Synchronization* ds=0;
  64. #endif
  66. #define DELIMITER   0x001B8
  69. /*
  70.  *
  71.  * De-multiplexor
  72.  *
  73.  */
  75. Mpeg2Demux::Mpeg2Demux(int pdu_size, int sel_vstream, int sel_astream, int a_on, int v_on, int s_on, int q) :
  76.   pes_audio_bytes(0),
  77.   pes_video_bytes(0),
  78.   pes_audio_time(0.0),
  79.   pes_video_time(0.0),
  80.   audio_on(a_on),
  81.   video_on(v_on),
  82.   sync_on(s_on),
  83.   quiet(q),
  84.   vstream(sel_vstream),
  85.   astream(sel_astream)
  86. {
  87.   audio_buffer=new Mpeg2Buffer(audio_buffer_size);
  88.   video_buffer=new Mpeg2Buffer(video_buffer_size);
  89. #ifdef TRACE
  90.   ::ab=audio_buffer;
  91.   ::vb=video_buffer;
  92. #endif
  94.   aalpdu_size=pdu_size;
  95.   aalpdu=new unsigned char[aalpdu_size+1];
  96.   aalpdu_max=aalpdu+aalpdu_size;
  98.   // input counters
  99.   bytecount=0;
  100.   byteptr=0;
  101.   pdu_mpeg_packet=aalpdu_max; // set to max for proper init
  102.   // MPEG packet counters 
  103.   counter=0;
  104.   transport_packets=0;
  105.   transport_packet_errors=0;
  106.   sync_byte_errors=0;
  107.   lost_packets=0;
  108.   adaptation_fields=0;
  109.   program_association_tables=0;
  110.   pes_packets=0;
  111.   psi_packets=0;
  112.   audio_packets=0;
  113.   video_packets=0;
  114.   // transport packet header information
  115.   transport_error_indicator=0;
  116.   payload_unit_start_indicator=0;
  117.   pid=0;
  118.   audio_pid=-1;
  119.   video_pid=-1;
  120.   adaptation_field_control=0;
  122.   audio=0;
  123.   video=0;
  124.   sync=0;
  126.   int err;
  127. #ifdef EOFEXIT
  128.   Mpeg2Demux::init(this);
  129. #else
  130.   if ((err=athr_create((void*(*)(void*))Mpeg2Demux::init, this, &thread_id))<0){
  131.     error("could not create thread");
  132.   }
  133.   sched_param param;
  134.   int policy;
  135.   if ((err=athr_getschedparam(thread_id, &policy, &param))<0){
  136.     warning("could not get thread prio - ignored");
  137.   }
  138.   else {
  139. #ifdef LINUX
  140.     param.sched_priority+=1;
  141. //    policy = SCHED_RR;
  142.     TRACER("TIMERPRIORITY=" << param.sched_priority << "(" << param.sched_priority-1 << ")");
  143. #else
  144.     param.prio+=1;
  145.     TRACER("TIMERPRIORITY=" << param.prio << "(" << param.prio-1 << ")");
  146. #endif
  147.     if ((err=athr_setschedparam(thread_id, policy, &param))<0){
  148.       warning("could not set thread prio - ignored");
  149.     }
  150.   }
  152. //  TRACER("DEMUXPRIORITY=" << param.prio);
  153. #endif
  154.   terminated=0;
  155. }
  158. Mpeg2Demux::~Mpeg2Demux(){
  159.   TRACER("Mpeg2Demux::~Mpeg2Demux()");
  160.   if (!terminated){ // check if thread is still alive
  161.     TRACER("waiting for demux thread to terminate ...");
  162.     athr_join(thread_id);
  163.   }
  165.   TRACER("delete video ...");
  166.   delete video;
  167.   TRACER("video deletedndelete audio ...");
  168.   delete audio;
  169.   TRACER("audio deletedndelete sync ...");
  170.   delete sync;
  171.   TRACER("sync deletedndemux deleted");
  172.   delete aalpdu;
  173.   delete audio_buffer;
  174.   delete video_buffer;
  175. }
  178. int Mpeg2Demux::stop(){
  179.   terminate=1;
  180.   if (!terminated){    // check to see if thread is available
  181.     athr_join(thread_id);
  182.     gettimeofday(&tstop,(struct timezone *)NULL); 
  183.     int runtime = 1000*(tstop.tv_sec-tstart.tv_sec) + (tstop.tv_usec-tstart.tv_usec)/1000;
  184.     msg("Bitrate: "); 
  185.     msg(dtoa(counter*MPEG2_TS_Packet_size*8/runtime));
  186.     message(" Kbps");
  187.   }
  188.   return terminated; 
  189. }
  192. void* Mpeg2Demux::init(Mpeg2Demux* base){
  193.   TRACER("void* Mpeg2Demux::init(Mpeg2Demux* base)");
  194.   base->terminate=0;
  195.   base->terminated=0;
  197.   if (base->sync_on){
  198.     if (base->video_on && base->audio_on)
  199.       base->sync=new Synchronization(0, time_stamp_qsize, frame_stamp_qsize); // sync video/audio
  200.     if (base->video_on && !base->audio_on)
  201.       base->sync=new Synchronization(1, time_stamp_qsize, frame_stamp_qsize); // just video
  202.     if (!base->video_on && base->audio_on)
  203.       base->sync=new Synchronization(2, time_stamp_qsize, frame_stamp_qsize); // just audio
  204.   }
  205.   else base->sync=0;
  207.   if (base->video_on)
  208.     base->video=new Mpeg2Video(base->video_buffer, base->sync, video_argc, video_argv);
  209.   else base->video=0;
  211.   if (base->audio_on)
  212.     base->audio=new Mpeg2Audio(base->audio_buffer, base->sync, base->audio_on, audio_argc, audio_argv);
  213.   else base->audio=0;
  215.   // wait for network connection or file to be ready!
  216.   sock->accept();
  217.   if (0){
  218.     error("could not receive connection!");
  219.     athr_exit(0);
  220.   }
  222.   if (base->nextpacket()<=0){  // init first pdu
  223.     error("could not read first packet");
  224.     athr_exit(0);
  225.   }
  226.   unsigned int bits=base->nextbits32();
  228.   gettimeofday(&base->tstart,(struct timezone *)NULL); 
  230.   if (((bits >> 24) & 0xff)==Sync_byte){
  231.     message("Playing MPEG 2 TS Audio/Video");
  232. #ifdef TRACE
  233.     ::ds=base->sync;
  234. #endif      
  235.     base->transport_stream();
  236.   }
  237.   else if (bits == Pack_start_code){
  238.     // Create players and start
  239.     message("Playing MPEG 2 PS Audio/Video");
  240.     base->program_stream();
  241.   }
  242.   else if (base->audio_on && (bits & 0xfff00000)==0xfff00000){  // just plain audio
  243.     message("Playing MPEG 2 PES Audio");
  244.     base->pes_stream_audio();
  245.   }
  246.   else if (base->video_on && bits==Sequence_start_code){ // just video
  247.     message("Playing MPEG 2 PES Video");
  248.     base->pes_stream_video();
  249.   }
  250.   else error("Stream is not valid MPEG 2 Stream (TS, PS, Audio ES, Video ES)");
  251.   base->stop();
  252.   base->terminated=1;
  253.   TRACER("demux thread done");
  255. #ifdef EOFEXIT
  256.   exit(0);  // stop everything right here (after EOF!)
  257. #else
  258.   athr_exit(0);
  259. #endif
  260.   return 0;
  261. }
  264. int Mpeg2Demux::copybytes(Mpeg2Buffer* output, int length){
  265.   if (bytecount+length>MPEG2_TS_Packet_size){
  266.     warning("copying bytes beyond transport packet length");
  267.     length=MPEG2_TS_Packet_size-bytecount;
  268.   }
  269.   if (output->write(byteptr, length)!=length){
  270.     error("failed to copy input to output");    // write to output
  271.   }
  272.   bytecount+=length;
  273.   byteptr+=length;
  274.   return length;
  275. }
  278. int Mpeg2Demux::skipbytes(int length){
  279.   int i = length;
  280.   while(i--)
  281.     getbits8();
  282.   return length;
  284.   if (bytecount+length>MPEG2_TS_Packet_size){
  285.     warning("skipping bytes beyond transport packet length");
  286.     length=MPEG2_TS_Packet_size - bytecount;
  287.   }
  288.   bytecount+=length;
  289.   byteptr+=length;
  290.   return length;
  291. }
  293. int Mpeg2Demux::copy_ps_bytes(Mpeg2Buffer* output, unsigned int *header,int len){
  294.   unsigned char c;
  295. //    if (video_on == 2) {
  296.       if (output->write(byteptr, len)!=len){
  297.         error("failed to copy input to output");    // write to output
  298.       }
  299.       if (!nextpacket()) {
  300.         *header = 0;
  301.         return 1;
  302.       }
  303.       *header = getbits32();
  304. #if 0
  305.     }
  306.     else {
  307.       *header = getbits32();
  308.       while ((*header <= DELIMITER) || (*header > 0x1ff)) {
  309.         c = *header >> 24;
  310.         *header = (*header << 8) | getbits8();
  311.         if (output->write(&c, 1)!=1){
  312.           error("failed to copy input to output");    // write to output
  313.         }
  314.       }
  315.     }
  316. #endif
  317.   return 0;
  318. }
  321. int Mpeg2Demux::skip_ps_bytes(unsigned int *header){
  322. //  if (video_on==2) {
  323.     if (!nextpacket()) {
  324.       *header = 0;
  325.       return 1;
  326.     }
  327.     *header = getbits32();
  328.     return 0;
  329. #if 0
  330.   }
  331.   else {
  332.     *header = getbits32();
  333.     while ((*header <= DELIMITER) || (*header >  0x1ff)){
  334.       *header = (*header << 8) |  getbits8();
  335.     }
  336.   }
  337. #endif
  338.   return 0;
  339. }
  343. int Mpeg2Demux::nextpacket(){  
  345.   DEBUGGER("int Mpeg2Demux::nextpacket()");
  347.   if (pdu_mpeg_packet>=aalpdu_max){
  348.     DEBUGGER("sock->recv()");
  349.     if ((lastpdu_size=sock->recv(aalpdu, aalpdu_size))!=aalpdu_size){
  350.       if (lastpdu_size==0){
  351.        
  352. // if (audio_buffer)
  353. //          while (audio_buffer->used() > 10000 )  sleep(1);
  354. // if (video_buffer) 
  355. //          while (video_buffer->used() > 30000 ) sleep(1);
  356. sleep(1);
  357.         terminate=1;
  358.         if (sync) sync->stop();
  359.         if (audio) audio->stop();
  360.         if (video) video->stop();
  361. sleep(1);
  362.         if (sync) sync->stop();
  363.         TRACER("EOF!");
  364.         return 0; // eof
  365.       }
  366.       error("invalid pdu size (" << itoa(lastpdu_size) << ")");
  367.       return -1;
  368.     }
  369.     byteptr=pdu_mpeg_packet=aalpdu;
  370.     pdu_mpeg_packet+=MPEG2_TS_Packet_size;
  371.     bytecount=0;
  372.   }
  373.   else {
  374.     byteptr=pdu_mpeg_packet;
  375.     pdu_mpeg_packet+=MPEG2_TS_Packet_size;
  376.     bytecount=0;
  377.   }
  378.   return 1;
  379. }
  381. /*
  382.  *
  383.  * Mpeg Transport Stream
  384.  *
  385.  */
  387. int Mpeg2Demux::transport_stream(){
  388.   do {
  389.     counter++;
  391.     if (!get_transport_packet()){
  392.       if (!quiet){
  393.         String err("incorrect packet ");
  394.         err+=itoa(counter);
  395.         error(err.chars());
  396.       }
  397.     }
  399.     if (!quiet){
  400.       if ((counter % 100)==0) msg(".");
  401.       if ((counter % 5000)==0){
  402.         message(itoa(counter));
  403.         athr_yield();
  404.       }
  405.     }
  407.     if (terminate){
  408.       if ((!sync || sync->stop()) && (!audio || audio->stop()) && (!video || video->stop()))
  409.         break;  // continue until all threads terminated
  410.     }
  411.   }
  412.   while (nextpacket());
  414.   TRACER("closing audio buffer ...");
  415.   audio_buffer->close();
  416.   TRACER("closed audio buffernclosing video buffer ...");
  417.   video_buffer->close();
  418.   TRACER("closed video buffer");
  419.   file.close();
  421.   return (counter==0) ? 0 : 1;
  422. }
  425. int Mpeg2Demux::get_transport_packet(){  
  426.   if (get_sync_byte()){              // align with sync
  427.     transport_packets++;
  429.     unsigned int bits=(getbits24() & 0x0000ffff);  // drop sync byte
  430.     // printf("First 2 bytes: %dn", bits);
  431.     // exit(0);
  432.     transport_error_indicator=bits >> 15;
  433.     payload_unit_start_indicator=(bits >> 14) & 1;
  434.     pid=bits & 0x00001fff;
  435.     transport_scrambling_control=(nextbits8() >> 6)&0x3;
  436.     adaptation_field_control=(nextbits8() >> 4)&0x3;
  437.     continuity_counter=(getbits8()&0xf);
  439.     if (transport_error_indicator){
  440.       transport_packet_errors++;
  441.       return 0;  // error set!
  442.     }
  444.     if (pid==0x1fff){
  445.       return 1;  // padding; just go to next
  446.     }
  447.     int i;
  448.     for (i=0; pidtable[i]!=0 && pid!=pidtable[i]; i++); // get pid
  449.     if (pidtable[i]==0){  // not in table yet
  450.       pidtable[i]=pid;
  451.       continuity_counters[i]=continuity_counter;  // init
  452.       pidtable[i+1]=0;
  453.     }
  454.     
  455.     if (pid!=(int)Program_Association_Table && pid!=(int)Conditional_Access_Table
  456.         && (adaptation_field_control==1 || adaptation_field_control==3)){
  457.       // Check counters
  458.       if (continuity_counters[i]!=continuity_counter){
  459.         if (!quiet){
  460.           String err("lost MPEG ");
  461.           err+=itoa(continuity_counter-continuity_counters[i]);
  462.           err+=" packet(s)";
  463.           error(err.chars());
  464.         }
  465.         continuity_counters[i]=continuity_counter; // reset
  466.         lost_packets++;
  467.       }
  468.       if (++continuity_counters[i]>15) continuity_counters[i]=0;
  469.     }
  471.     if (adaptation_field_control==2 || adaptation_field_control==3)
  472.       get_adaptation_field();
  473.     if (adaptation_field_control==1 || adaptation_field_control==3)
  474.       get_payload();
  476.   }
  477.   else {
  478.     sync_byte_errors++;
  479.     return 0;
  480.   }
  481.   return 1;
  482. }
  485. int Mpeg2Demux::get_adaptation_field(){
  486.   adaptation_fields++;
  487.   int length=getbits8();                        // get adaptation field length
  488. // int discontinuity_indicator=(nextbits8() >> 7);
  489. // int random_access_indicator=(nextbits8() >> 6) & 1;
  490. // int elem_prio_indicator=(nextbits8() >> 5) & 1; // not used at this point;
  491.   int pcr_flag=(getbits8() >> 4) & 1;           // get first byte
  493.   if (pcr_flag){
  494.     unsigned long clk_ref_base=getbits32();
  495.     unsigned int clk_ref_ext=getbits16();
  496.     if (clk_ref_base>0x7fffffff){   // correct for invalid numbers
  497.       clk_ref_base=0;               // ie. longer than 32 bits when multiplied by 2
  498.       clk_ref_ext=0;                // multiplied by 2 corresponds to shift left 1 (<<=1)
  499.     }
  500.     else {
  501.       clk_ref_base<<=1; // Create space for bit
  502.       clk_ref_base|=(clk_ref_ext >> 15);          // Take bit
  503.       clk_ref_ext&=0x01ff;                        // Only lower 9 bits
  504.     }
  505.     
  506.     double time=clk_ref_base + clk_ref_ext/300;
  507.     TRACER("Time: " << dtoa(time));
  508.     if (sync) sync->put(time);  // id=0, Timer
  510.     if (length) skipbytes(length - 7);
  511.   }
  512.   else skipbytes(length - 1);
  514.   return 1;
  515. }
  518. int Mpeg2Demux::get_payload(){
  519.   if (payload_unit_start_indicator){
  520.     if (pid==0) get_program_association_table();
  521.     else if (nextbits24()==Packet_start_code_prefix) get_pes_packet();
  522.     else skipbytes(MPEG2_TS_Packet_size - bytecount);  // get_psi_packet();
  523.   }
  524.   else {
  525.     if (pid==audio_pid) get_audio_data();
  526.     else if (pid==video_pid) get_video_data();
  527.     else skipbytes(MPEG2_TS_Packet_size - bytecount);
  528.   }
  530.   return 1;
  531. }
  533. int Mpeg2Demux::get_program_association_table(){
  534.   program_association_tables++;
  536.   table_id=getbits8();
  537.   section_length=getbits16() & 0xfff;   // last 12 bits
  538.   transport_stream_id=getbits16();
  539.   
  540.   skipbytes(MPEG2_TS_Packet_size-bytecount);
  541. /*  
  542.   for (int i=0; i<section_length-9; i+=4) getbits32();
  543.   i-=4;
  545.   if ((i+9)>(MPEG2_TS_Packet_size-4)) error("too many bytes in program association table");
  546. */
  547.   return 1;
  548. }
  551. int Mpeg2Demux::get_pes_packet_data(int stream_id){
  552.   unsigned long pts(0), dts(0);
  554.   if ((stream_id >> 4)==12 || (stream_id >> 4)==13){
  555.     // Just pick the first available stream if no ID is set
  556.     if (astream==-1)
  557.       astream=(stream_id & 0x0f);
  559.     if ((stream_id & 0x0f)==astream && audio_on){
  560.       if (sync && pes_audio_bytes){
  561.     TRACER("AudioTime: " << dtoa(pes_audio_time) << " " << itoa(pes_audio_bytes));
  562.         sync->put(2, pes_audio_time, pes_audio_bytes); // id=2, Audio
  563.         pes_audio_time=0;
  564.         pes_audio_bytes=0;
  565.       }
  566.       get_pes_packet_header(pts, dts);
  567.       pes_audio_time=pts;
  568.       audio_pid=pid;
  569.       return get_audio_data();
  570.     }
  571.   }
  572.   else if ((stream_id >> 4)==14){
  573.     // Just pick the first available stream if no ID is set
  574.     if (vstream==-1)
  575.       vstream=(stream_id & 0x0f);
  577.     if ((stream_id & 0x0f)==vstream && video_on){
  578.       if (sync && pes_video_bytes){
  579.     TRACER("VideoTime: " << dtoa(pes_video_time) << " " << itoa(pes_video_bytes));
  580.         sync->put(1, pes_video_time, pes_video_bytes); // id=1, Video
  581.         pes_video_time=0;
  582.         pes_video_bytes=0;
  583.       }
  584.       get_pes_packet_header(pts, dts);
  585.       pes_video_time=pts;
  586.       video_pid=pid;
  587.       return get_video_data();
  588.     }
  589.   }
  590.   else {
  591.     return get_unknown_data();
  592.   }
  593.   skipbytes(MPEG2_TS_Packet_size - bytecount);
  595.   return 1;
  596. }
  598. int Mpeg2Demux::get_pes_packet_header(unsigned long& pts, unsigned long& dts){
  599.   unsigned int pes_header_bytes(0);
  601.   getbits8();  // drop first 8 bits
  602.   short PTS_DTS_flags=(getbits8() >> 6) & 0x3;
  603.   int PES_header_data_length=getbits8();
  605.   // Get Presentation Time stamps and Decoding Time Stamps
  606.   if (PTS_DTS_flags==2){
  607.     pts=(getbits8() >> 1) & 7;  // Only low 4 bits (7==1111)
  608.     pts<<=15;
  609.     pts|=(getbits16() >> 1);
  610.     pts<<=15;
  611.     pts|=(getbits16() >> 1);
  612.     pes_header_bytes+=5;
  613.   }
  614.   else if (PTS_DTS_flags==3){      
  615.     pts=(getbits8() >> 1) & 7;  // Only low 4 bits (7==1111)
  616.     pts<<=15;
  617.     pts|=(getbits16() >> 1);
  618.     pts<<=15;
  619.     pts|=(getbits16() >> 1);
  620.     dts=(getbits8() >> 1) & 7;  // Only low 4 bits (7==1111)
  621.     dts<<=15;
  622.     dts|=(getbits16() >> 1);
  623.     dts<<=15;
  624.     dts|=(getbits16() >> 1);
  625.     pes_header_bytes+=10;
  626.   }
  627.   // extract other stuff here!
  628.   
  629.   skipbytes(PES_header_data_length - pes_header_bytes);
  630.   return 1;
  631. }
  633. int Mpeg2Demux::get_pes_packet(){
  634.   pes_packets++;
  636.   getbits24();     // skip startcode
  637.   unsigned int stream_id=getbits8();
  639. //  int pes_packet_length=   // Not used at this point; just drop
  640.   getbits16();
  642.   if (stream_id!=Private_stream_2 && stream_id!=Padding_stream){
  643.     return get_pes_packet_data(stream_id);
  644.   }
  645.   else if (stream_id==Private_stream_2){
  646.     // Dump private data!
  647.     error("private stream");
  648.     skipbytes(MPEG2_TS_Packet_size - bytecount);
  649.   }
  650.   else if (stream_id==Padding_stream){
  651.     skipbytes(MPEG2_TS_Packet_size - bytecount);
  652.     // Nothing; the next search for a sync byte will just skip the stuffing bytes
  653.   }
  654.   else {
  655.     error("unknown stream_id in pes packet");
  656.     skipbytes(MPEG2_TS_Packet_size - bytecount);
  657.   }
  659.   return 1;
  660. }
  663. int Mpeg2Demux::get_psi_packet(){
  664.   psi_packets++;
  665.   table_id=getbits8();
  666.   section_length=getbits16() & 0x0fff;
  668.   skipbytes(MPEG2_TS_Packet_size - bytecount);
  669.   return 1;
  670. }
  673. int Mpeg2Demux::get_audio_data(){
  674.   audio_packets++;
  675.   pes_audio_bytes+=copybytes(audio_buffer, MPEG2_TS_Packet_size - bytecount);
  676.   return 1;
  677. }
  679. int Mpeg2Demux::get_video_data(){
  680.   video_packets++;
  681.   pes_video_bytes+=copybytes(video_buffer, MPEG2_TS_Packet_size - bytecount);
  682.   return 1;
  683. }
  685. int Mpeg2Demux::get_unknown_data(){
  686.   warning("unknown data in PSI or PES packet");
  687.   return skipbytes(MPEG2_TS_Packet_size - bytecount);
  688. }
  690. /*
  691.  *
  692.  * MPEG Program Stream
  693.  *
  694.  */
  697. int Mpeg2Demux::program_stream(){
  699.   if (!get_program_pack()){
  700.     error("failure in programm pack");
  701.     return 0;
  702.   }
  703.   audio_buffer->close();
  704.   video_buffer->close();
  705.   return 1;
  706. }
  708. int Mpeg2Demux::get_program_pack(){
  709. static unsigned int header;
  711.   header = getbits32();
  713.   while (1) {
  715.     if (header == Pack_start_code) {
  716.   get_pack_header(&header);
  717.     }
  718.     else if ((header >> 8) == Packet_start_code_prefix) {
  719.        counter++;
  720.        get_ps_pes_packet(&header);
  721.     }
  722.     else { 
  723.       return 0;
  724.     }
  726.     if (!quiet){
  727.       if ((counter % 100)==0) msg(".");
  728.       if ((counter % 5000)==0){
  729.         message(itoa(counter));
  730.       }
  731.     }
  732.     
  733.     if (terminate){
  734. //      if ((!sync || sync->stop()) && (!audio && audio->stop()) && (!video && video->stop()))
  735.         break;
  736.     }
  737.   }
  739.   return 1;
  740. }
  743. int Mpeg2Demux::get_ps_pes_packet(unsigned int *header){
  744.   static unsigned long pts(0),dts(0);
  745.   int PES_header_data_length;
  746.   pes_packets++;
  747.   int stream_id=*header & 0xff;
  748.   unsigned int pes_packet_length=getbits16();
  749.   if (stream_id!=(int)Private_stream_2 && stream_id!=(int)Padding_stream){
  751. pts = 0;
  752.     if ((nextbits8() & 0xc0) == 0x40) {
  753.       pes_packet_length -= 12;
  754.         skipbytes(12);
  755.     } 
  756.     else {
  757.       int pes_header_bytes=0;
  758.       int scrambling = (getbits8() >> 4 ) & 3;
  759. //      if (scrambling) {
  760. //        message("scrambled data");
  761. //        skip_ps_bytes(header);            
  762. //        return 1;
  763. //      }
  764.       int PTS_DTS_flags=(getbits8() >> 6) & 0x3;
  765.       PES_header_data_length=getbits8();
  766.   // Get Presentation Time stamps and Decoding Time Stamps
  767.       if (PTS_DTS_flags==2){
  768.         pts=(getbits8() >> 1) & 7;  // Only low 4 bits (7==1111)
  769.         pts<<=15;
  770.         pts|=(getbits16() >> 1);
  771.         pts<<=15;
  772.         pts|=(getbits16() >> 1);
  773.         pes_header_bytes+=5;
  774.       }
  775.       else if (PTS_DTS_flags==3){
  776.         pts=(getbits8() >> 1) & 7;  // Only low 4 bits (7==1111)
  777.         pts<<=15;
  778.         pts|=(getbits16() >> 1);
  779.         pts<<=15;
  780.         pts|=(getbits16() >> 1);
  781.         dts=(getbits8() >> 1) & 7;  // Only low 4 bits (7==1111)
  782.         dts<<=15;
  783.         dts|=(getbits16() >> 1);
  784.         dts<<=15;
  785.         dts|=(getbits16() >> 1);
  786.         pes_header_bytes+=10;
  787.       }
  788.      // extract other stuff here!
  791.       pes_packet_length -=3;
  792.       if (PES_header_data_length) {
  793.         pes_packet_length -= PES_header_data_length; 
  794.         skipbytes (PES_header_data_length - pes_header_bytes);
  795.       }
  796.     }
  798.     if ((stream_id >> 4)==12 || (stream_id >> 4)==13){
  799.       if ((stream_id & 0x0f)== astream && audio_on==1){
  800.         if (sync && pes_audio_bytes && pts ){
  801.           TRACER("AudioTime: " << dtoa(pes_audio_time));
  802.           sync->put(2, pes_audio_time, pes_audio_bytes); // id=2, Audio
  803.           pes_audio_time=0;
  804.           pes_audio_bytes=0;
  805.   
  806.         }
  807. if (pts)
  808.           pes_audio_time=pts;
  809.         pes_audio_bytes+=pes_packet_length;
  810.         copy_ps_bytes(audio_buffer, header,pes_packet_length);            
  811.       }
  812.       else {
  813.         skip_ps_bytes(header);            
  814.       }
  815.     }
  816.     else if ((stream_id >> 4)==14){
  817.       if ((stream_id & 0x0f)== vstream && video_on){
  818.         if (sync &&  pes_video_bytes && pts){
  819.           TRACER("VideoTime: " << dtoa(pes_video_time) << " " << itoa(pes_video_bytes));
  820.           sync->put(1, pes_video_time,pes_video_bytes); // id=1, Video
  821.           pes_video_time=0;
  822.           pes_video_bytes=0;
  823.         }
  824.         if (pts)
  825.           pes_video_time=pts;
  826.         pes_video_bytes += pes_packet_length;
  827.         copy_ps_bytes(video_buffer, header,pes_packet_length);            
  828.       }
  829.       else {
  830.         skip_ps_bytes(header);            
  831.       }
  832.     }
  833.     else if (stream_id == 0xbd){
  834.       if ( (*byteptr == (0x80+astream) ) && audio_on==2){  /* AC-3 Data */
  835.         if (sync &&  pes_audio_bytes && pts){
  836.           TRACER("AudioTime: " << dtoa(pes_audio_time) << " " << itoa(pes_audio_bytes));
  837.           sync->put(2, pes_audio_time, pes_audio_bytes); // id=2, Audio
  838.           pes_audio_time=0;
  839.           pes_audio_bytes=0;
  840.         }
  841.         if (pts)
  842.           pes_audio_time=pts;
  843.         pes_audio_bytes+=pes_packet_length-4;
  844. skipbytes(4);
  845.         copy_ps_bytes(audio_buffer, header,pes_packet_length-4);
  846.       }
  847.       else {
  848.         skip_ps_bytes(header);
  849.       }
  850.     }
  851.     else if (stream_id == 0xbc){
  852.       skip_ps_bytes(header);            
  853.     }
  854.     else {
  855.       skip_ps_bytes(header);            
  856.     }
  857.   }
  858.   else if (stream_id==(int)Private_stream_2){
  859.     skip_ps_bytes(header);            
  860.   }
  861.   else if (stream_id == (int)Padding_stream){
  862.     skip_ps_bytes(header);            
  863.   }
  864.   else error("unknown stream_id in pes packet");
  866.   return 1;
  867. }
  870. int Mpeg2Demux::get_pack_header(unsigned int *header){
  871. static double old_time = 0.0;
  872. unsigned long i,j;
  873. unsigned long clock_ref,clock_ref_ext;
  874.   i = getbits32();
  875.   j = getbits16();
  876.   if (i & 0x40000000) {
  877.     clock_ref =  ((i & 0x31000000) << 3);
  878.     clock_ref |= ((i & 0x03fff800) << 4);
  879.     clock_ref |= ((i & 0x000003ff) << 5);
  880.     clock_ref |= ((j & 0xf800) >> 11);
  881.     clock_ref_ext = (j >> 1) & 0x1ff;
  883.     double time=clock_ref + clock_ref_ext/300;
  884.     TRACER("Time: " << dtoa(time));
  885.     if (sync && (old_time + 6000 < time)) {
  886.        sync->put(time);  // id=0, Timer
  887.        old_time = time;
  888.     }
  889.    
  890.     skipbytes(3);
  891.     i = getbits8() & 0x7;
  892.     while (i--) 
  893.       getbits8(); // stuffing 
  894.   }
  895.   else
  896.     skipbytes(2);
  897.   *header = getbits32();
  898.   
  899.   if (*header == System_start_code) {
  900.     get_system_header();
  901.     *header = getbits32();
  902.   }
  903.   return 1;
  904. }
  906. int Mpeg2Demux::get_system_header(){
  907. int i;
  908.   i = getbits16(); // get length
  909.   while (i--)
  910.     getbits8();
  911.   return 1;
  912. }
  915. /*
  916.  *  Packetized Elementary Stream (PES)
  917.  */
  920. int Mpeg2Demux::pes_stream_audio(){
  921.   do {
  922.     counter++;
  924.     get_audio_data();
  926.     if (!quiet){
  927.       if ((counter % 100)==0) msg(".");
  928.       if ((counter % 5000)==0){
  929.         message(itoa(counter));
  930.       }
  931.     } 
  932.   }
  933.   while (nextpacket());
  935.   audio_buffer->close();
  937.   return 1;
  938. }
  939.  
  940. int Mpeg2Demux::pes_stream_video(){
  941.   do {
  942.     counter++;
  944.     get_video_data();
  946.     if (!quiet){
  947.       if ((counter % 100)==0) msg(".");
  948.       if ((counter % 5000)==0){
  949.         message(itoa(counter));
  950.       }
  951.     }
  952.   }
  953.   while (nextpacket());
  955.   video_buffer->close();
  957.   return 1;
  958. }