Examples/DVBAdapter/ULEdec.cc

   1 // $Id$
   2 //
   3 // Copyright (C) 2006
   4 // Fraunhofer Institut fuer offene Kommunikationssysteme (FOKUS)
   5 // Kompetenzzentrum fuer Satelitenkommunikation (SatCom)
   6 //     Stefan Bund <stefan.bund@fokus.fraunhofer.de>
   7 //
   8 // This program is free software; you can redistribute it and/or modify
   9 // it under the terms of the GNU General Public License as published by
  10 // the Free Software Foundation; either version 2 of the License, or
  11 // (at your option) any later version.
  12 //
  13 // This program is distributed in the hope that it will be useful,
  14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 // GNU General Public License for more details.
  17 //
  18 // You should have received a copy of the GNU General Public License
  19 // along with this program; if not, write to the
  20 // Free Software Foundation, Inc.,
  21 // 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  22
  23 // Definition of non-inline non-template functions
  24
  25 #include "ULEdec.hh"
  26
  27 #include "Packets/PacketData.hh"
  28 #include "Utils/hexdump.hh"
  29 #include "Utils/membind.hh"
  30
  31 #define PID 271
  32 #define TS_SYNC 0x47
  33
  34 #define prefix_
  35 ///////////////////////////////cc.p////////////////////////////////////////
  36
  37
  38 ULEdec::ULEdec()
  39 {
  40     struct dmx_pes_filter_params pes_filter;
  41     memset(&pes_filter, 0, sizeof (struct dmx_pes_filter_params));
  42     pes_filter.pid = PID;
  43     pes_filter.input  = DMX_IN_FRONTEND;
  44     pes_filter.output = DMX_OUT_TS_TAP;
  45     pes_filter.pes_type = DMX_PES_OTHER;
  46     pes_filter.flags = DMX_IMMEDIATE_START;
  47     demuxHandle.protocol().setPESFilter( &pes_filter );
  48
  49     senf::Scheduler::instance().add(
  50         dvrHandle, senf::membind(&ULEdec::handleEvent, this));
  51
  52     this->receiver_state = Idle;
  53     this->priv_sndu_type_1 = false;
  54 }
  55
  56 void ULEdec::handleEvent(senf::FileHandle, senf::Scheduler::EventId event)
  57 {
  58     senf::TransportPacket ts_packet (
  59             senf::TransportPacket::create(188, senf::TransportPacket::noinit));
  60     dvrHandle.read( ts_packet.data() );
  61
  62     // Check TS error conditions: sync_byte, transport_error_indicator, scrambling_control.
  63     if ( (ts_packet->sync_byte() != TS_SYNC) ||
  64          (ts_packet->transport_error_indicator() == true) ||
  65          (ts_packet->transport_scrmbl_ctrl() != 0))
  66     {
  67         std::cerr << "invalid ts packet\n";
  68         // drop partly decoded SNDU, reset state, resync on PUSI.
  69         return;
  70     }
  71
  72     handleTSPacket(ts_packet);
  73 }
  74
  75 void ULEdec::handleTSPacket(senf::TransportPacket ts_packet)
  76 {
  77     senf::PacketData & payloadData (ts_packet.next().data());
  78     iterator payload_start = payloadData.begin();
  79     iterator payload_end = payloadData.end();
  80
  81     std::cout << "New TS Packet:\n"
  82               << "----------------------------------------------------------------------------\n";
  83     senf::hexdump(payload_start, payload_end, std::cout);
  84     std::cout << "----------------------------------------------------------------------------\n";
  85
  86     // Synchronize continuity counter
  87     this->priv_tscc = ts_packet->continuity_counter();
  88
  89     switch (ts_packet->pusi()) {
  90     case 0: {
  91         switch (this->receiver_state) {
  92         case Idle:
  93             return;
  94         case Reassembly:
  95             payload_start = readContSNDUPacket( payload_start, payload_end );
  96             if (isSDNUPacketComplete()) {
  97                 handleSNDUPacket();
  98                 this->receiver_state = Idle;
  99                 switch (std::distance( payload_start, payload_end ))
 100                 case 0:
 101                 case 1:
 102                     return;
 103                 default:
 104                     if ( (*payload_start++ << 8 | *payload_start++) != ULE_END_INDICATOR )
 105                         std::cerr << "delimiting error 1\n";
 106             } else {
 107                 BOOST_ASSERT( std::distance( payload_start, payload_end ) == 0 );
 108             }
 109         }
 110         break;
 111     }
 112     case 1: {
 113         // a PUSI value of 1 indicates the presence of a Payload Pointer.
 114         unsigned char payload_pointer = *payload_start++;
 115         if (payload_pointer > 181) {
 116             std::cerr << "invalid payload_pointer\n";
 117             this->receiver_state = Idle;
 118             return;
 119         }
 120         switch (this->receiver_state) {
 121         case Idle:
 122             payload_start += payload_pointer;
 123             break;
 124         case Reassembly:
 125             // Reassembly Payload Pointer Checking
 126             if (snduPacketBytesLeft() != payload_pointer) {
 127                 // delimiting error
 128                 std::cerr << "delimiting error 2\n";
 129                 payload_start += payload_pointer;
 130             } else {
 131                 payload_start = readContSNDUPacket( payload_start, payload_end );
 132                 BOOST_ASSERT( isSDNUPacketComplete() );
 133                 handleSNDUPacket();
 134             }
 135         }
 136         do {
 137             payload_start = readNewSNDUPacket( payload_start, payload_end );
 138             if (! isSDNUPacketComplete()) {
 139                 BOOST_ASSERT( std::distance( payload_start, payload_end ) == 0 );
 140                 this->receiver_state = Reassembly;
 141                 break;
 142             }
 143             handleSNDUPacket();
 144             this->receiver_state = Idle;
 145         } while (std::distance(payload_start, payload_end) < 2 );
 146     }
 147
 148     } // end pusi-switch
 149 }
 150
 151
 152 ULEdec::iterator ULEdec::readContSNDUPacket(iterator i_start, iterator i_end)
 153 {
 154     if (priv_sndu_type_1) {
 155         this->snduPacket->type() |= *i_start++;
 156     }
 157     i_start = readRawSNDUPacketData(i_start, i_end);
 158
 159     return i_start;
 160 }
 161
 162
 163 ULEdec::iterator ULEdec::readNewSNDUPacket(iterator i_start, iterator i_end)
 164 {
 165     bool dbit = false;
 166     senf::Packet::size_type sndu_length;
 167     sndu_length = *i_start++ << 8 | *i_start++;
 168     if (sndu_length & 0x8000) {
 169         sndu_length &= 0x7FFF;
 170         dbit = true;
 171     }
 172     this->snduPacket = senf::SNDUPacket::create(sndu_length+4);
 173     this->snduPacket->d_bit() = dbit;
 174     this->snduPacket->length() = sndu_length;
 175     this->snduPacketData_iter = this->snduPacket.data().begin() + 2;
 176     this->priv_sndu_type_1 = false;
 177
 178     switch (std::distance(i_start, i_end)) {
 179     case 1:
 180         this->priv_sndu_type_1 = true;
 181         this->snduPacket->type() = *i_start++ << 8;
 182         this->snduPacketData_iter++;
 183     case 0:
 184         break;
 185
 186     default:
 187         this->snduPacket->type() = *i_start++ << 8 | *i_start++;
 188         this->snduPacketData_iter += 2;
 189         i_start = readRawSNDUPacketData(i_start, i_end);
 190     }
 191
 192     return i_start;
 193 }
 194
 195
 196 ULEdec::iterator ULEdec::readRawSNDUPacketData(iterator i_start, iterator i_end)
 197 {
 198     unsigned char how_much = std::min(
 199             snduPacketBytesLeft(), std::distance( i_start, i_end ) );
 200     copy_n(i_start, how_much, this->snduPacketData_iter);
 201     i_start += how_much;
 202     this->snduPacketData_iter += how_much;
 203     return i_start;
 204 }
 205
 206
 207 void ULEdec::handleSNDUPacket()
 208 {
 209     this->snduPacket.dump(std::cout);
 210     std::cout << "  calculated CRC: " << this->snduPacket->calcCrc() << "\n";
 211     std::cout << "----------------------------------------------------------------------------\n\n";
 212 }
 213
 214
 215 inline bool ULEdec::isSDNUPacketComplete()
 216 {
 217     return this->snduPacketData_iter == this->snduPacket.data().end();
 218 }
 219
 220 inline ULEdec::iterator::difference_type ULEdec::snduPacketBytesLeft()
 221 {
 222     return std::distance( this->snduPacketData_iter, this->snduPacket.data().end() );
 223 }
 224
 225
 226 int main(int argc, char const * argv[])
 227 {
 228     try {
 229         ULEdec decoder;
 230         senf::Scheduler::instance().process();
 231     }
 232     catch (std::exception const & ex) {
 233         std::cerr << senf::prettyName(typeid(ex)) << ": " << ex.what() << "\n";
 234     }
 235     return 0;
 236 }
 237
 238
 239 ///////////////////////////////cc.e////////////////////////////////////////
 240 #undef prefix_
 241
 242
 243 // Local Variables:
 244 // mode: c++
 245 // fill-column: 100
 246 // c-file-style: "senf"
 247 // indent-tabs-mode: nil
 248 // ispell-local-dictionary: "american"
 249 // compile-command: "scons -u test"
 250 // comment-column: 40
 251 // End: