src/ARIB/si.cpp

   1
   2 #include <stdio.h>
   3 #include "si.h"
   4
   5 using namespace TS::PSI;
   6 using namespace TS::PSI::ARIB;
   7 using namespace TS::Description;
   8 using namespace TS::Description::ARIB;
   9
  10 ServiceInformation::ServiceInformation( int32_t id,  DescriptorParser *des_parser)
  11         : Section( id, des_parser)
  12 {
  13         si_id.transport_stream_id       = 0x00;
  14         reserved_2                                      = 0x00;
  15         version_number                          = 0x00;
  16         current_next_indicator          = 0x00;
  17         section_number                          = 0x00;
  18         last_section_number                     = 0x00;
  19 }
  20
  21 ServiceInformation::~ServiceInformation()
  22 {
  23 }
  24
  25 ServiceInformation::STATUS ServiceInformation::parse( SectionBuffer &sec)
  26 {
  27         if( section_syntax_indicator != 0) {
  28                 if( sec.length() < SI_PARSE_SIZE) {
  29                         return ERROR_PARSE_SECTION;
  30                 }
  31
  32                 si_id.transport_stream_id       = (sec[ 0] << 8) + sec[ 1];
  33                 reserved_2                                      = (sec[ 2] >> 6) & 0x03;
  34                 version_number                          = (sec[ 2] >> 1) & 0x1f;
  35                 current_next_indicator          = (sec[ 2] >> 0) & 0x01;
  36                 section_number                          =  sec[ 3];
  37                 last_section_number                     =  sec[ 4];
  38
  39                 sec += SI_PARSE_SIZE;
  40         }
  41
  42         return SUCCESS;
  43 }
  44
  45
  46 NIT::NIT( DescriptorParser *des_parser)
  47         : ServiceInformation( -1, des_parser)
  48 {
  49         reserved_future_use1                    = 0x00;
  50         network_descriptors_length              = 0x00;
  51         reserved_future_use2                    = 0x00;
  52         transport_stream_loop_length    = 0x00;
  53 }
  54
  55 NIT::~NIT()
  56 {
  57         clearNIT();
  58 }
  59
  60 void NIT::clear()
  61 {
  62         clearNIT();
  63         ServiceInformation::clear();
  64 }
  65
  66 NIT::STATUS NIT::parse( SectionBuffer &sec)
  67 {
  68         int32_t         size = 0;
  69         STREAM          s;
  70
  71         clearNIT();
  72
  73         STATUS state = ServiceInformation::parse( sec);
  74         if( state != SUCCESS) {
  75                 return state;
  76         }
  77
  78         if( sec.length() < 2) {
  79                 return ERROR_PARSE_SECTION;
  80         }
  81         reserved_future_use1                    = (sec[ 0] >> 4) & 0x0f;
  82         network_descriptors_length              = ((sec[ 0] & 0x0f) << 8) + sec[ 1];
  83         sec += 2;
  84         if( sec.length() < network_descriptors_length) {
  85                 return ERROR_PARSE_SECTION;
  86         }
  87         size = parseDescriptors( sec, network_descriptors_length, &networks);
  88         if( size == -1) {
  89                 return ERROR_PARSE_SECTION;
  90         }
  91         sec += size;
  92
  93         if( sec.length() < 2) {
  94                 return ERROR_PARSE_SECTION;
  95         }
  96         reserved_future_use2                    = (sec[ 0] >> 4) & 0x0f;
  97         transport_stream_loop_length    = ((sec[ 0] & 0x0f) << 8) + sec[ 1];
  98         sec += 2;
  99
 100         while( sec.length() >= STREAM_HEADER_SIZE) {
 101                 s.transport_stream_id                   = (sec[ 0] << 8) + sec[ 1];
 102                 s.original_network_id                   = (sec[ 2] << 8) + sec[ 3];
 103                 s.reserved_future_use                   = (sec[ 4] >> 4) & 0x0f;
 104                 s.transport_descriptors_length  = ((sec[ 4] & 0x0f) << 8) + sec[ 5];
 105                 sec += STREAM_HEADER_SIZE;
 106                 if( sec.length() < s.transport_descriptors_length) {
 107                         return ERROR_PARSE_SECTION;
 108                 }
 109
 110                 size = parseDescriptors( sec, s.transport_descriptors_length, &s.descriptors);
 111                 if( size == -1) {
 112                         return ERROR_PARSE_SECTION;
 113                 }
 114                 sec += size;
 115                 streams.push_back( s);
 116         }
 117
 118         erase_buffer = true;
 119         return SUCCESS;
 120 }
 121
 122 bool NIT::checkID( uint8_t id)
 123 {
 124         if( id == 0x40 || id <= 0x41) {
 125                 return true;
 126         }
 127         else {
 128                 return false;
 129         }
 130 }
 131
 132 void NIT::clearNIT()
 133 {
 134         STREAMS::iterator               i;
 135
 136         clearDescriptors( &networks);
 137
 138         for( i = streams.begin(); i != streams.end(); i++) {
 139                 clearDescriptors( &i->descriptors);
 140         }
 141         streams.clear();
 142 }
 143
 144
 145 SDT::SDT( DescriptorParser *des_parser)
 146         : ServiceInformation( -1, des_parser)
 147 {
 148         original_network_id     = 0x00;
 149         reserved_future_use     = 0x00;
 150 }
 151
 152 SDT::~SDT()
 153 {
 154         clearSDT();
 155 }
 156
 157 void SDT::clear()
 158 {
 159         clearSDT();
 160         ServiceInformation::clear();
 161 }
 162
 163 SDT::STATUS SDT::parse( SectionBuffer &sec)
 164 {
 165         int32_t         size = 0;
 166         SERVICE         s;
 167
 168         clearSDT();
 169
 170         STATUS state = ServiceInformation::parse( sec);
 171         if( state != SUCCESS) {
 172                 return state;
 173         }
 174
 175         if( sec.length() < SD_PARSE_SIZE) {
 176                 return ERROR_PARSE_SECTION;
 177         }
 178         original_network_id                     = (sec[ 0] << 8) + sec[ 1];
 179         reserved_future_use                     =  sec[ 2];
 180         sec += SD_PARSE_SIZE;
 181
 182         while( sec.length() >= SERVICE_HEADER_SIZE) {
 183                 s.service_id                                    = (sec[ 0] << 8) + sec[ 1];
 184                 s.reserved_future_use                   = (sec[ 2] >> 5) & 0x07;
 185                 s.EIT_user_defined_flags                = (sec[ 2] >> 2) & 0x07;
 186                 s.EIT_schedule_flag                             = (sec[ 2] >> 1) & 0x01;
 187                 s.EIT_present_following_flag    = (sec[ 2] >> 0) & 0x01;
 188                 s.running_status                                = (sec[ 3] >> 5) & 0x07;
 189                 s.free_CA_mode                                  = (sec[ 3] >> 4) & 0x01;
 190                 s.descriptors_loop_length               = ((sec[ 3] & 0x0f) << 8) + sec[ 4];
 191                 sec += SERVICE_HEADER_SIZE;
 192                 if( sec.length() < s.descriptors_loop_length) {
 193                         return ERROR_PARSE_SECTION;
 194                 }
 195
 196                 size = parseDescriptors( sec, s.descriptors_loop_length, &s.descriptors);
 197                 if( size == -1) {
 198                         return ERROR_PARSE_SECTION;
 199                 }
 200                 sec += size;
 201                 services.push_back( s);
 202         }
 203
 204         erase_buffer = true;
 205         return SUCCESS;
 206 }
 207
 208 bool SDT::checkID( uint8_t id)
 209 {
 210         if( id == 0x42 || id <= 0x46) {
 211                 return true;
 212         }
 213         else {
 214                 return false;
 215         }
 216 }
 217
 218 void SDT::clearSDT()
 219 {
 220         SERVICES::iterator              i;
 221
 222         for( i = services.begin(); i != services.end(); i++) {
 223                 clearDescriptors( &i->descriptors);
 224         }
 225         services.clear();
 226 }
 227
 228
 229
 230 EIT::EIT( DescriptorParser *des_parser)
 231         : ServiceInformation( -1, des_parser)
 232 {
 233         transport_stream_id                     = 0x00;
 234         original_network_id                     = 0x00;
 235         segment_last_section_number     = 0x00;
 236         last_table_id                           = 0x00;
 237 }
 238
 239 EIT::~EIT()
 240 {
 241         clearEIT();
 242 }
 243
 244 void EIT::clear()
 245 {
 246         clearEIT();
 247         ServiceInformation::clear();
 248 }
 249
 250 EIT::STATUS EIT::parse( SectionBuffer &sec)
 251 {
 252         int32_t         size = 0;
 253         EVENT           e;
 254
 255         clearEIT();
 256
 257         STATUS state = ServiceInformation::parse( sec);
 258         if( state != SUCCESS) {
 259                 return state;
 260         }
 261
 262         if( sec.length() < EI_PARSE_SIZE) {
 263                 return ERROR_PARSE_SECTION;
 264         }
 265         transport_stream_id             = (sec[ 0] << 8) + sec[ 1];
 266         original_network_id                     = (sec[ 2] << 8) + sec[ 3];
 267         segment_last_section_number     =  sec[ 4];
 268         last_table_id                           =  sec[ 5];
 269         sec += EI_PARSE_SIZE;
 270
 271         while( sec.length() >= EVENT_HEADER_SIZE) {
 272                 e.event_id                                      = (sec[ 0] << 8) + sec[ 1];
 273                 e.start_time                            = Converter::date( &sec[ 2]);
 274                 e.duration                                      = Converter::time( &sec[ 7]);
 275                 e.running_status                        = (sec[ 10] >> 5) & 0x07;
 276                 e.free_CA_mode                          = (sec[ 10] >> 4) & 0x01;
 277                 e.descriptors_loop_length       = ((sec[ 10] & 0x0f) << 8) + sec[ 11];
 278                 sec += EVENT_HEADER_SIZE;
 279                 if( sec.length() < e.descriptors_loop_length) {
 280                         return ERROR_PARSE_SECTION;
 281                 }
 282
 283                 size = parseDescriptors( sec, e.descriptors_loop_length, &e.descriptors);
 284                 if( size == -1) {
 285                         return ERROR_PARSE_SECTION;
 286                 }
 287                 sec += size;
 288                 events.push_back( e);
 289         }
 290
 291         erase_buffer = true;
 292         return SUCCESS;
 293 }
 294
 295 bool EIT::checkID( uint8_t id)
 296 {
 297         if( id >= 0x4E && id <= 0x6F) {
 298                 return true;
 299         }
 300         else {
 301                 return false;
 302         }
 303 }
 304
 305 void EIT::clearEIT()
 306 {
 307         EVENTS::iterator                i;
 308
 309         for( i = events.begin(); i != events.end(); i++) {
 310                 clearDescriptors( &i->descriptors);
 311         }
 312         events.clear();
 313 }
 314
 315
 316
 317 TDT::TDT( DescriptorParser *des_parser)
 318         : Section( -1, des_parser)
 319 {
 320 }
 321
 322 TDT::~TDT()
 323 {
 324 }
 325
 326 TDT::STATUS TDT::parse( SectionBuffer &sec)
 327 {
 328         int32_t         size = 0;
 329
 330         if( sec.length() < TD_PARSE_SIZE) {
 331                 return ERROR_PARSE_SECTION;
 332         }
 333
 334         JST_time                                = Converter::date( &sec[ 0]);
 335         sec += TD_PARSE_SIZE;
 336
 337         erase_buffer = true;
 338         return SUCCESS;
 339 }
 340
 341 bool TDT::checkID( uint8_t id)
 342 {
 343         return (id == TDT_ID);
 344 }
 345
 346
 347
 348
 349 TOT::TOT( DescriptorParser *des_parser)
 350         : TDT( des_parser)
 351 {
 352 }
 353
 354 TOT::~TOT()
 355 {
 356         clearTOT();
 357 }
 358
 359 void TOT::clear()
 360 {
 361         clearTOT();
 362         Section::clear();
 363 }
 364
 365 TOT::STATUS TOT::parse( SectionBuffer &sec)
 366 {
 367         int32_t         size = 0;
 368
 369         clearTOT();
 370
 371         STATUS state = TDT::parse( sec);
 372         if( state != SUCCESS) {
 373                 return state;
 374         }
 375         if( table_id == TDT_ID) {
 376                 return SUCCESS;
 377         }
 378
 379         if( sec.length() < TO_PARSE_SIZE) {
 380                 return ERROR_PARSE_SECTION;
 381         }
 382
 383         reserved_2                              = (sec[ 0] >> 4) & 0x0f;
 384         descriptors_loop_length = ((sec[ 0] & 0x0f) << 8) + sec[ 1];
 385         sec += TO_PARSE_SIZE;
 386
 387         size = parseDescriptors( sec, descriptors_loop_length, &descriptors);
 388         if( size == -1) {
 389                 return ERROR_PARSE_SECTION;
 390         }
 391         sec += size;
 392
 393         erase_buffer = true;
 394         return SUCCESS;
 395 }
 396
 397 bool TOT::checkID( uint8_t id)
 398 {
 399         if( TDT::checkID( id)) {
 400                 return true;
 401         }
 402         else if( id == TOT_ID) {
 403                 return true;
 404         }
 405         else {
 406                 return false;
 407         }
 408 }
 409
 410 void TOT::clearTOT()
 411 {
 412         clearDescriptors( &descriptors);
 413 }
 414