src/TS/ts_packet.h

   1 #pragma once
   2
   3 #include <inttypes.h>
   4 #include <stdlib.h>
   5 #include "utils.h"
   6
   7 namespace TS {
   8
   9 class Header {
  10 public:
  11         static const int                TS_HEADER_SZIE  = 4;
  12         static const uint8_t    SYNC                    = 0x47;
  13
  14 private:
  15         uint8_t                         header[ TS_HEADER_SZIE];
  16
  17 #ifdef PACKET_DEBUG
  18         uint8_t                         sync_byte;                                                              //  8bit
  19         uint8_t                         transport_error_indicator;                              //  1bit
  20         uint8_t                         payload_unit_start_indicator;                   //  1bit
  21         uint8_t                         transport_priority;                                             //  1bit
  22         uint16_t                        pid;                                                                    // 13bit
  23         uint8_t                         transport_scrambling_control;                   //  2bit
  24         uint8_t                         adaptation_field_control;                               //  2bit
  25         uint8_t                         continuity_counter;                                             //  4bit
  26 #endif
  27
  28 public:
  29         Header();
  30         virtual ~Header();
  31
  32         int                                     getBytes( uint8_t *buf, uint32_t size);
  33         int                                     parse( const uint8_t *buf, uint32_t len);
  34
  35         uint32_t                        size();
  36
  37         uint8_t                         getTransportErrorIndicator();
  38         uint8_t                         getPayloadUnitStartIndicator();
  39         uint8_t                         getTransportPriority();
  40         uint16_t                        getPid();
  41         uint8_t                         getTransportScramblingControl();
  42         uint8_t                         getAdaptationFieldControl();
  43         uint8_t                         getContinuityCounter();
  44
  45         void                            setTransportErrorIndicator( uint8_t val);
  46         void                            setPayloadUnitStartIndicator( uint8_t val);
  47         void                            setTransportPriority( uint8_t val);
  48         void                            setPid( uint16_t val);
  49         void                            setTransportScramblingControl( uint8_t val);
  50         void                            setAdaptationFieldControl( uint8_t val);
  51         void                            setContinuityCounter( uint8_t val) ;
  52 };
  53
  54 class AdaptationField {
  55 private:
  56         uint8_t                         *adaptation_field;
  57
  58 #ifdef PACKET_DEBUG
  59         uint8_t                         adaptation_field_length;                                //  8bit
  60         uint8_t                         discontinuity_indicator;                                //  1bit
  61         uint8_t                         random_access_indicator;                                //  1bit
  62         uint8_t                         elementary_stream_priority_indicator;   //  1bit
  63         uint8_t                         PCR_flag;                                                               //  1bit
  64         uint8_t                         OPCR_flag;                                                              //  1bit
  65         uint8_t                         splicing_point_flag;                                    //  1bit
  66         uint8_t                         transport_private_data_flag;                    //  1bit
  67         uint8_t                         adaptation_field_extension_flag;                //  1bit
  68 #endif
  69
  70         uint8_t                         *field_data;
  71         uint32_t                        field_data_length;
  72
  73 public:
  74         AdaptationField();
  75         AdaptationField( AdaptationField &src);
  76         virtual ~AdaptationField();
  77
  78         int                                     getBytes( uint8_t *buf, uint32_t size);
  79         int                                     parse( uint8_t *buf, uint32_t len);
  80
  81         uint32_t                        size();
  82
  83         uint8_t                         getAdaptationFieldLength();                                     //  8bit
  84         uint8_t                         getDiscontinuityIndicator();                                    //  1bit
  85         uint8_t                         getRandomAccessIndicator();                                     //  1bit
  86         uint8_t                         getElementaryStreamPriorityIndicator(); //  1bit
  87         uint8_t                         getPCRFlag();                                                                   //  1bit
  88         uint8_t                         getOPCRFlag();                                                                  //  1bit
  89         uint8_t                         getSplicingPointFlag();                                         //  1bit
  90         uint8_t                         getTransportPrivateDataFlag();                          //  1bit
  91         uint8_t                         getAdaptationFieldExtensionFlag();                      //  1bit
  92
  93
  94         AdaptationField&        operator=( AdaptationField &src);
  95
  96 private:
  97         void                    copy( AdaptationField &dst);
  98         void                    clear();
  99 };
 100
 101
 102 class TSPacket {
 103 public:
 104         static const int TS_PACKET_SIZE = 188;
 105
 106 private:
 107         Header                          *header;
 108         AdaptationField         *adaptation_field;
 109     uint8_t                             *payload;
 110         uint32_t                        payload_length;
 111
 112 private:
 113         TSPacket( Header *h, AdaptationField *af, uint8_t *p, uint32_t p_len);
 114
 115 public:
 116         virtual ~TSPacket();
 117
 118 public:
 119         uint16_t                        getPID();
 120         Header*                         getHeader();
 121         AdaptationField*        getAdaptationField();
 122         uint32_t                        getPayloadLength();
 123         uint32_t                        getPayload( uint8_t **p);
 124
 125         int                                     getBytes( uint8_t *buf, uint32_t size);
 126
 127         static TSPacket*        parse( uint8_t *buf, uint32_t len, uint32_t *read_len);
 128         static TSPacket*        create( Header *h, AdaptationField *af, uint8_t *p, uint32_t p_len);
 129
 130 private:
 131         static int                      sync( uint8_t *buf, uint32_t len) ;
 132 };
 133
 134
 135
 136 inline uint32_t Header::size()
 137 {
 138         return TS_HEADER_SZIE;
 139 }
 140
 141 inline uint8_t Header::getTransportErrorIndicator()
 142 {
 143         return Bits::get( header[ 1], 7, 0x01);
 144 }
 145
 146 inline void Header::setTransportErrorIndicator( uint8_t val)
 147 {
 148         Bits::set( &header[ 1], val, 7, 0x01);
 149 }
 150
 151 inline uint8_t Header::getPayloadUnitStartIndicator()
 152 {
 153         return Bits::get( header[ 1], 6, 0x01);
 154 }
 155
 156 inline void Header::setPayloadUnitStartIndicator( uint8_t val)
 157 {
 158         Bits::set( &header[ 1], val, 6, 0x01);
 159 }
 160
 161 inline uint8_t Header::getTransportPriority()
 162 {
 163         return Bits::get( header[ 1], 5, 0x01);
 164 }
 165
 166 inline void Header::setTransportPriority( uint8_t val)
 167 {
 168         Bits::set( &header[ 1], val, 5, 0x01);
 169 }
 170
 171 inline uint16_t Header::getPid()
 172 {
 173         return (Bits::get( header[ 1], 0, 0x1f) << 8) + header[ 2];
 174 }
 175
 176 inline void Header::setPid( uint16_t val)
 177 {
 178         Bits::set( &header[ 1], (uint8_t)(val >> 8), 0, 0x1f);
 179         header[ 2] = val & 0xff;
 180 }
 181
 182 inline uint8_t Header::getTransportScramblingControl()
 183 {
 184         return Bits::get( header[ 3], 6, 0x03);
 185 }
 186
 187 inline void Header::setTransportScramblingControl( uint8_t val)
 188 {
 189         Bits::set( &header[ 3], val, 6, 0x03);
 190 }
 191
 192 inline uint8_t Header::getAdaptationFieldControl()
 193 {
 194         return Bits::get( header[ 3], 4, 0x03);
 195 }
 196
 197 inline void Header::setAdaptationFieldControl( uint8_t val)
 198 {
 199         Bits::set( &header[ 3], val, 4, 0x03);
 200 }
 201
 202 inline uint8_t Header::getContinuityCounter()
 203 {
 204         return Bits::get( header[ 3], 0, 0x0f);
 205 }
 206
 207 inline void Header::setContinuityCounter( uint8_t val)
 208 {
 209         Bits::set( &header[ 3], val, 0, 0x0f);
 210 }
 211
 212
 213
 214 inline uint32_t AdaptationField::size()
 215 {
 216         return getAdaptationFieldLength() + 1;
 217 }
 218
 219 inline uint8_t AdaptationField::getAdaptationFieldLength()
 220 {
 221         if( adaptation_field) {
 222                 return adaptation_field[ 0];
 223         }
 224         else {
 225                 return 0;
 226         }
 227 }
 228
 229 inline uint8_t AdaptationField::getDiscontinuityIndicator()
 230 {
 231         if( adaptation_field) {
 232                 return Bits::get( adaptation_field[ 1], 7, 0x01);
 233         }
 234         else {
 235                 return 0;
 236         }
 237 }
 238
 239 inline uint8_t AdaptationField::getRandomAccessIndicator()
 240 {
 241         if( adaptation_field) {
 242                 return Bits::get( adaptation_field[ 1], 6, 0x01);
 243         }
 244         else {
 245                 return 0;
 246         }
 247 }
 248
 249 inline uint8_t AdaptationField::getElementaryStreamPriorityIndicator()
 250 {
 251         if( adaptation_field) {
 252                 return Bits::get( adaptation_field[ 1], 5, 0x01);
 253         }
 254         else {
 255                 return 0;
 256         }
 257 }
 258
 259 inline uint8_t AdaptationField::getPCRFlag()
 260 {
 261         if( adaptation_field) {
 262                 return Bits::get( adaptation_field[ 1], 4, 0x01);
 263         }
 264         else {
 265                 return 0;
 266         }
 267 }
 268
 269 inline uint8_t AdaptationField::getOPCRFlag()
 270 {
 271         if( adaptation_field) {
 272                 return Bits::get( adaptation_field[ 1], 3, 0x01);
 273         }
 274         else {
 275                 return 0;
 276         }
 277 }
 278
 279 inline uint8_t AdaptationField::getSplicingPointFlag()
 280 {
 281         if( adaptation_field) {
 282                 return Bits::get( adaptation_field[ 1], 2, 0x01);
 283         }
 284         else {
 285                 return 0;
 286         }
 287 }
 288
 289 inline uint8_t AdaptationField::getTransportPrivateDataFlag()
 290 {
 291         if( adaptation_field) {
 292                 return Bits::get( adaptation_field[ 1], 1, 0x01);
 293         }
 294         else {
 295                 return 0;
 296         }
 297 }
 298
 299 inline uint8_t AdaptationField::getAdaptationFieldExtensionFlag()
 300 {
 301         if( adaptation_field) {
 302                 return Bits::get( adaptation_field[ 1], 0, 0x01);
 303         }
 304         else {
 305                 return 0;
 306         }
 307 }
 308
 309 }
 310