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;\r
 149         reserved_future_use     = 0x00;\r
 150 }\r
 151 \r
 152 SDT::~SDT()\r
 153 {
 154         clearSDT();\r
 155 }
 156
 157 void SDT::clear()
 158 {
 159         clearSDT();
 160         ServiceInformation::clear();
 161 }\r
 162 \r
 163 SDT::STATUS SDT::parse( SectionBuffer &sec)\r
 164 {
 165         int32_t         size = 0;\r
 166         SERVICE         s;
 167
 168         clearSDT();\r
 169         \r
 170         STATUS state = ServiceInformation::parse( sec);\r
 171         if( state != SUCCESS) {\r
 172                 return state;\r
 173         }\r
 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];\r
 180         sec += SD_PARSE_SIZE;
 181         \r
 182         while( sec.length() >= SERVICE_HEADER_SIZE) {\r
 183                 s.service_id                                    = (sec[ 0] << 8) + sec[ 1];\r
 184                 s.reserved_future_use                   = (sec[ 2] >> 5) & 0x07;\r
 185                 s.EIT_user_defined_flags                = (sec[ 2] >> 2) & 0x07;\r
 186                 s.EIT_schedule_flag                             = (sec[ 2] >> 1) & 0x01;\r
 187                 s.EIT_present_following_flag    = (sec[ 2] >> 0) & 0x01;\r
 188                 s.running_status                                = (sec[ 3] >> 5) & 0x07;\r
 189                 s.free_CA_mode                                  = (sec[ 3] >> 4) & 0x01;\r
 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;\r
 201                 services.push_back( s);
 202         }\r
 203         \r
 204         erase_buffer = true;\r
 205         return SUCCESS;\r
 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;\r
 234         original_network_id                     = 0x00;\r
 235         segment_last_section_number     = 0x00;\r
 236         last_table_id                           = 0x00;\r
 237 }\r
 238 \r
 239 EIT::~EIT()\r
 240 {
 241         clearEIT();\r
 242 }
 243
 244 void EIT::clear()
 245 {
 246         clearEIT();
 247         ServiceInformation::clear();
 248 }\r
 249 \r
 250 EIT::STATUS EIT::parse( SectionBuffer &sec)\r
 251 {
 252         int32_t         size = 0;\r
 253         EVENT           e;
 254
 255         clearEIT();\r
 256         \r
 257         STATUS state = ServiceInformation::parse( sec);\r
 258         if( state != SUCCESS) {\r
 259                 return state;\r
 260         }\r
 261
 262         if( sec.length() < EI_PARSE_SIZE) {
 263                 return ERROR_PARSE_SECTION;
 264         }\r
 265         transport_stream_id             = (sec[ 0] << 8) + sec[ 1];\r
 266         original_network_id                     = (sec[ 2] << 8) + sec[ 3];\r
 267         segment_last_section_number     =  sec[ 4];\r
 268         last_table_id                           =  sec[ 5];\r
 269         sec += EI_PARSE_SIZE;
 270         \r
 271         while( sec.length() >= EVENT_HEADER_SIZE) {\r
 272                 e.event_id                                      = (sec[ 0] << 8) + sec[ 1];\r
 273                 e.start_time                            = Converter::date( &sec[ 2]);\r
 274                 e.duration                                      = Converter::time( &sec[ 7]);\r
 275                 e.running_status                        = (sec[ 10] >> 5) & 0x07;\r
 276                 e.free_CA_mode                          = (sec[ 10] >> 4) & 0x01;\r
 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;\r
 288                 events.push_back( e);
 289         }\r
 290         \r
 291         erase_buffer = true;\r
 292         return SUCCESS;\r
 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 }\r
 314 \r
 315 \r
 316 \r
 317 TDT::TDT( DescriptorParser *des_parser)\r
 318         : Section( -1, des_parser)\r
 319 {\r
 320 }\r
 321 \r
 322 TDT::~TDT()\r
 323 {\r
 324 }\r
 325 \r
 326 TDT::STATUS TDT::parse( SectionBuffer &sec)\r
 327 {\r
 328         int32_t         size = 0;\r
 329         \r
 330         if( sec.length() < TD_PARSE_SIZE) {\r
 331                 return ERROR_PARSE_SECTION;\r
 332         }\r
 333         \r
 334         JST_time                                = Converter::date( &sec[ 0]);\r
 335         sec += TD_PARSE_SIZE;\r
 336         \r
 337         erase_buffer = true;\r
 338         return SUCCESS;\r
 339 }\r
 340 \r
 341 bool TDT::checkID( uint8_t id)\r
 342 {\r
 343         return (id == TDT_ID);\r
 344 }\r
 345 \r
 346 \r
 347 \r
 348 \r
 349 TOT::TOT( DescriptorParser *des_parser)\r
 350         : TDT( des_parser)\r
 351 {\r
 352 }\r
 353 \r
 354 TOT::~TOT()\r
 355 {\r
 356         clearTOT();\r
 357 }\r
 358 \r
 359 void TOT::clear()\r
 360 {\r
 361         clearTOT();\r
 362         Section::clear();\r
 363 }\r
 364 \r
 365 TOT::STATUS TOT::parse( SectionBuffer &sec)\r
 366 {\r
 367         int32_t         size = 0;\r
 368         \r
 369         clearTOT();\r
 370         \r
 371         STATUS state = TDT::parse( sec);\r
 372         if( state != SUCCESS) {\r
 373                 return state;\r
 374         }\r
 375         if( table_id == TDT_ID) {\r
 376                 return SUCCESS;\r
 377         }\r
 378         \r
 379         if( sec.length() < TO_PARSE_SIZE) {\r
 380                 return ERROR_PARSE_SECTION;\r
 381         }\r
 382         \r
 383         reserved_2                              = (sec[ 0] >> 4) & 0x0f;\r
 384         descriptors_loop_length = ((sec[ 0] & 0x0f) << 8) + sec[ 1];\r
 385         sec += TO_PARSE_SIZE;\r
 386 \r
 387         size = parseDescriptors( sec, descriptors_loop_length, &descriptors);\r
 388         if( size == -1) {\r
 389                 return ERROR_PARSE_SECTION;\r
 390         }\r
 391         sec += size;\r
 392         \r
 393         erase_buffer = true;\r
 394         return SUCCESS;\r
 395 }\r
 396 \r
 397 bool TOT::checkID( uint8_t id)\r
 398 {
 399         if( TDT::checkID( id)) {
 400                 return true;
 401         }
 402         else if( id == TOT_ID) {
 403                 return true;
 404         }
 405         else {\r
 406                 return false;
 407         }\r
 408 }\r
 409 \r
 410 void TOT::clearTOT()\r
 411 {\r
 412         clearDescriptors( &descriptors);\r
 413 }\r
 414 \r