src/mpeg2/ts/Demultiplexer.cpp

   1 /**
   2  * @file Demultiplexer.cpp
   3  *
   4  */
   5
   6 #include "mpeg2/ts/Demultiplexer.h"
   7
   8 namespace MPEG2
   9 {
  10 namespace TS
  11 {
  12
  13 Demultiplexer::Demultiplexer()
  14 {
  15     MPEG2_MUTEX_INIT;
  16
  17     _flag = 0;
  18
  19     _continuity_counter_sdt  = 0xFF;
  20     _continuity_counter_0012 = 0xFF;
  21     _continuity_counter_0026 = 0xFF;
  22     _continuity_counter_0027 = 0xFF;
  23 }
  24
  25 Demultiplexer::~Demultiplexer()
  26 {
  27     MPEG2_MUTEX_DESTROY;
  28 }
  29
  30 void Demultiplexer::setListener(Listener *listener)
  31 {
  32     MPEG2_LOCK;
  33     _listener = listener;
  34     MPEG2_UNLOCK;
  35 }
  36
  37 void Demultiplexer::setFlag(uint32_t flag, bool onoff)
  38 {
  39     MPEG2_LOCK;
  40     if (onoff)
  41     {
  42         _flag |= flag;
  43     }
  44     else
  45     {
  46         _flag &= ~flag;
  47     }
  48     MPEG2_UNLOCK;
  49 }
  50
  51 void Demultiplexer::putSDT(Header *header, uint8_t *packet)
  52 {
  53     if (_continuity_counter_sdt != 0xFF)
  54     {
  55         if (((_continuity_counter_sdt + 1) & 0x0F) != header->_continuity_counter)
  56         {
  57             printf("packet loss\n");
  58             _sdt.reset();
  59             ((Table *)&_sdt)->reset();
  60         }
  61         _continuity_counter_sdt = header->_continuity_counter;
  62     }
  63     if (_sdt.decode(header, packet))
  64     {
  65         if ((_listener) && ((_flag & FLG_SDT) == FLG_SDT))
  66         {
  67             _listener->detect(&_sdt);
  68         }
  69         _sdt.reset();
  70     }
  71 }
  72
  73 void Demultiplexer::putEIT(Header *header, uint8_t *packet)
  74 {
  75     switch (header->_pid)
  76     {
  77     case PID_EIT_0012:
  78         if (_continuity_counter_0012 != 0xFF)
  79         {
  80             if (((_continuity_counter_0012 + 1) & 0x0F) != header->_continuity_counter)
  81             {
  82                 printf("packet loss\n");
  83                 _eit_0012.reset();
  84                 ((Table *)&_eit_0012)->reset();
  85             }
  86         }
  87         _continuity_counter_0012 = header->_continuity_counter;
  88         break;
  89
  90     case PID_EIT_0026:
  91         if (_continuity_counter_0026 != 0xFF)
  92         {
  93             if (((_continuity_counter_0026 + 1) & 0x0F) != header->_continuity_counter)
  94             {
  95                 printf("packet loss\n");
  96                 _eit_0026.reset();
  97                 ((Table *)&_eit_0026)->reset();
  98             }
  99         }
 100         _continuity_counter_0026 = header->_continuity_counter;
 101         break;
 102
 103     case PID_EIT_0027:
 104         if (_continuity_counter_0027 != 0xFF)
 105         {
 106             if (((_continuity_counter_0027 + 1) & 0x0F) != header->_continuity_counter)
 107             {
 108                 printf("packet loss\n");
 109                 _eit_0027.reset();
 110                 ((Table *)&_eit_0027)->reset();
 111             }
 112         }
 113         _continuity_counter_0027 = header->_continuity_counter;
 114         break;
 115     }
 116
 117     switch (header->_pid)
 118     {
 119     case PID_EIT_0012:
 120         if (_eit_0012.decode(header, packet))
 121         {
 122             if ((_listener) && ((_flag & FLG_EIT) == FLG_EIT))
 123             {
 124                 _listener->detect(&_eit_0012);
 125             }
 126             _eit_0012.reset();
 127         }
 128         break;
 129     case PID_EIT_0026:
 130         if (_eit_0026.decode(header, packet))
 131         {
 132             if ((_listener) && ((_flag & FLG_EIT) == FLG_EIT))
 133             {
 134                 _listener->detect(&_eit_0026);
 135             }
 136             _eit_0026.reset();
 137         }
 138         break;
 139     case PID_EIT_0027:
 140         if (_eit_0027.decode(header, packet))
 141         {
 142             if ((_listener) && ((_flag & FLG_EIT) == FLG_EIT))
 143             {
 144                 _listener->detect(&_eit_0027);
 145             }
 146             _eit_0027.reset();
 147         }
 148         break;
 149     }
 150 }
 151
 152 void Demultiplexer::put(uint8_t *buffer, uint32_t size)
 153 {
 154     uint32_t offset = 0;
 155     while (offset < size)
 156     {
 157         if (buffer[offset] != SYNC_BYTE)
 158         {
 159             break;
 160         }
 161
 162         MPEG2_LOCK;
 163
 164         Header header(&buffer[offset]);
 165         if (!header._transport_error)
 166         {
 167             switch (header._pid)
 168             {
 169             case PID_PAT:
 170                 break;
 171
 172             case PID_CAT:
 173                 break;
 174
 175             case PID_NIT:
 176                 break;
 177
 178             case PID_SDT_BAT:
 179                 putSDT(&header, &buffer[offset]);
 180                 break;
 181
 182             case PID_EIT_0012:
 183             case PID_EIT_0026:
 184             case PID_EIT_0027:
 185                 putEIT(&header, &buffer[offset]);
 186                 break;
 187
 188             case PID_RST:
 189                 break;
 190
 191             case PID_TDT:
 192                 break;
 193             }
 194         }
 195
 196         MPEG2_UNLOCK;
 197
 198         offset += PACKET_SIZE;
 199     }
 200 }
 201
 202
 203 } // TS
 204 } // MPEG2