vdr
1.7.27
|
00001 /*************************************************************************** 00002 * Copyright (c) 2003 by Marcel Wiesweg * 00003 * * 00004 * This program is free software; you can redistribute it and/or modify * 00005 * it under the terms of the GNU General Public License as published by * 00006 * the Free Software Foundation; either version 2 of the License, or * 00007 * (at your option) any later version. * 00008 * * 00009 * $Id: descriptor.c 2.4 2012/01/11 11:35:17 kls Exp $ 00010 * * 00011 ***************************************************************************/ 00012 00013 #include <string.h> 00014 #include "descriptor.h" 00015 00016 namespace SI { 00017 00018 void ShortEventDescriptor::Parse() { 00019 int offset=0; 00020 const descr_short_event *s; 00021 data.setPointerAndOffset<const descr_short_event>(s, offset); 00022 languageCode[0]=s->lang_code1; 00023 languageCode[1]=s->lang_code2; 00024 languageCode[2]=s->lang_code3; 00025 languageCode[3]=0; 00026 name.setDataAndOffset(data+offset, s->event_name_length, offset); 00027 const descr_short_event_mid *mid; 00028 data.setPointerAndOffset<const descr_short_event_mid>(mid, offset); 00029 text.setData(data+offset, mid->text_length); 00030 } 00031 00032 int ExtendedEventDescriptor::getDescriptorNumber() { 00033 return s->descriptor_number; 00034 } 00035 00036 int ExtendedEventDescriptor::getLastDescriptorNumber() { 00037 return s->last_descriptor_number; 00038 } 00039 00040 void ExtendedEventDescriptor::Parse() { 00041 int offset=0; 00042 data.setPointerAndOffset<const descr_extended_event>(s, offset); 00043 languageCode[0]=s->lang_code1; 00044 languageCode[1]=s->lang_code2; 00045 languageCode[2]=s->lang_code3; 00046 languageCode[3]=0; 00047 itemLoop.setDataAndOffset(data+offset, s->length_of_items, offset); 00048 const descr_extended_event_mid *mid; 00049 data.setPointerAndOffset<const descr_extended_event_mid>(mid, offset); 00050 text.setData(data+offset, mid->text_length); 00051 } 00052 00053 void ExtendedEventDescriptor::Item::Parse() { 00054 int offset=0; 00055 const item_extended_event *first; 00056 data.setPointerAndOffset<const item_extended_event>(first, offset); 00057 itemDescription.setDataAndOffset(data+offset, first->item_description_length, offset); 00058 const item_extended_event_mid *mid; 00059 data.setPointerAndOffset<const item_extended_event_mid>(mid, offset); 00060 item.setData(data+offset, mid->item_length); 00061 } 00062 00063 /*int ExtendedEventDescriptors::getTextLength() { 00064 int ret=0; 00065 for (int i=0;i<length;i++) { 00066 ExtendedEventDescriptor *d=(ExtendedEventDescriptor *)array[i]; 00067 if (!d) 00068 continue; 00069 ret+=d->text.getLength(); 00070 ExtendedEventDescriptor::Item item; 00071 for (Loop::Iterator it; d->itemLoop.hasNext(it); ) { 00072 item=d->itemLoop.getNext(it); 00073 ret+=item.item.getLength(); 00074 ret+=item.itemDescription.getLength(); 00075 ret+=2; //the blanks 00076 } 00077 } 00078 return ret; 00079 }*/ 00080 00081 int ExtendedEventDescriptors::getMaximumTextLength(const char *separation1, const char *separation2) { 00082 //add length of plain text, of itemized text with separators, and for one separator between the two fields. 00083 return getMaximumTextPlainLength()+getMaximumTextItemizedLength(separation1, separation2)+strlen(separation2); 00084 } 00085 00086 char *ExtendedEventDescriptors::getText(const char *separation1, const char *separation2) { 00087 int size = getMaximumTextLength(separation1, separation2); 00088 char *text=new char[size]; 00089 return getText(text, size, separation1, separation2); 00090 } 00091 00092 char *ExtendedEventDescriptors::getText(char *buffer, int size, const char *separation1, const char *separation2) { 00093 int index=0, len; 00094 for (int i=0;i<length;i++) { 00095 ExtendedEventDescriptor *d=(ExtendedEventDescriptor *)array[i]; 00096 if (!d) 00097 continue; 00098 d->text.getText(buffer+index, size); 00099 len = strlen(buffer+index); 00100 index += len; 00101 size -= len; 00102 } 00103 00104 int sepLen1 = strlen(separation1); 00105 int sepLen2 = strlen(separation2); 00106 bool separated = false; 00107 for (int i=0;i<length;i++) { 00108 ExtendedEventDescriptor *d=(ExtendedEventDescriptor *)array[i]; 00109 if (!d) 00110 continue; 00111 00112 ExtendedEventDescriptor::Item item; 00113 for (Loop::Iterator it; d->itemLoop.getNext(item, it); ) { 00114 if (!separated && size > sepLen2) { 00115 strcpy(buffer+index, separation2); // let's have a separator between the long text and the items 00116 index += sepLen2; 00117 size -= sepLen2; 00118 separated = true; 00119 } 00120 00121 item.itemDescription.getText(buffer+index, size); 00122 len = strlen(buffer+index); 00123 index += len; 00124 size -= len; 00125 if (size > sepLen1) { 00126 strcpy(buffer+index, separation1); 00127 index += sepLen1; 00128 size -= sepLen1; 00129 } 00130 00131 item.item.getText(buffer+index, size); 00132 len = strlen(buffer+index); 00133 index += len; 00134 size -= len; 00135 if (size > sepLen2) { 00136 strcpy(buffer+index, separation2); 00137 index += sepLen2; 00138 size -= sepLen2; 00139 } 00140 } 00141 } 00142 00143 buffer[index]='\0'; 00144 return buffer; 00145 } 00146 00147 int ExtendedEventDescriptors::getMaximumTextPlainLength() { 00148 int ret=0; 00149 for (int i=0;i<length;i++) { 00150 ExtendedEventDescriptor *d=(ExtendedEventDescriptor *)array[i]; 00151 if (!d) 00152 continue; 00153 ret+=d->text.getLength(); 00154 } 00155 return ret; 00156 } 00157 00158 char *ExtendedEventDescriptors::getTextPlain() { 00159 int size = getMaximumTextPlainLength(); 00160 char *text=new char[size]; 00161 return getTextPlain(text, size); 00162 } 00163 00164 char *ExtendedEventDescriptors::getTextPlain(char *buffer, int size) { 00165 int index=0, len; 00166 for (int i=0;i<length;i++) { 00167 ExtendedEventDescriptor *d=(ExtendedEventDescriptor *)array[i]; 00168 if (!d) 00169 continue; 00170 d->text.getText(buffer+index, size); 00171 len = strlen(buffer+index); 00172 index += len; 00173 size -= len; 00174 } 00175 buffer[index]='\0'; 00176 return buffer; 00177 } 00178 00179 int ExtendedEventDescriptors::getMaximumTextItemizedLength(const char *separation1, const char *separation2) { 00180 int ret=0; 00181 int sepLength=strlen(separation1)+strlen(separation2); 00182 for (int i=0;i<length;i++) { 00183 ExtendedEventDescriptor *d=(ExtendedEventDescriptor *)array[i]; 00184 if (!d) 00185 continue; 00186 //The length includes two 8-bit length fields which have already been subtracted from sepLength //XXX kls 2004-06-06: what does this mean??? 00187 ret+=d->itemLoop.getLength()+sepLength; 00188 } 00189 return ret; 00190 } 00191 00192 char *ExtendedEventDescriptors::getTextItemized(const char *separation1, const char *separation2) { 00193 int size = getMaximumTextItemizedLength(separation1, separation2); 00194 char *text=new char[size]; 00195 return getTextItemized(text, size, separation1, separation2); 00196 } 00197 00198 char *ExtendedEventDescriptors::getTextItemized(char *buffer, int size, const char *separation1, const char *separation2) { 00199 int index=0, len; 00200 int sepLen1 = strlen(separation1); 00201 int sepLen2 = strlen(separation2); 00202 for (int i=0;i<length;i++) { 00203 ExtendedEventDescriptor *d=(ExtendedEventDescriptor *)array[i]; 00204 if (!d) 00205 continue; 00206 00207 ExtendedEventDescriptor::Item item; 00208 for (Loop::Iterator it; d->itemLoop.getNext(item, it); ) { 00209 item.itemDescription.getText(buffer+index, size); 00210 len = strlen(buffer+index); 00211 index += len; 00212 size -= len; 00213 if (size > sepLen1) { 00214 strcpy(buffer+index, separation1); 00215 index += sepLen1; 00216 size -= sepLen1; 00217 } 00218 00219 item.item.getText(buffer+index, size); 00220 len = strlen(buffer+index); 00221 index += len; 00222 size -= len; 00223 if (size > sepLen2) { 00224 strcpy(buffer+index, separation2); 00225 index += sepLen2; 00226 size -= sepLen2; 00227 } 00228 } 00229 } 00230 buffer[index]='\0'; 00231 return buffer; 00232 } 00233 00234 //returns the itemized text pair by pair. Maximum length for buffers is 256. 00235 //Return value is false if and only if the end of the list is reached. 00236 bool ExtendedEventDescriptors::getTextItemized(Loop::Iterator &it, bool &valid, char *itemDescription, char *itemText, int sizeItemDescription, int sizeItemText) { 00237 //The iterator has to store two values: The descriptor index (4bit) 00238 //and the item loop index (max overall length 256, min item length 16 => max number 128 => 7bit) 00239 valid=false; 00240 00241 int index=(it.i & 0x780) >> 7; // 0x780 == 1111 000 0000 00242 it.i &= 0x7F; //0x7F == 111 1111 00243 00244 for (;index<length;index++) { 00245 ExtendedEventDescriptor *d=(ExtendedEventDescriptor *)array[index]; 00246 if (!d) 00247 continue; 00248 00249 ExtendedEventDescriptor::Item item; 00250 if (d->itemLoop.getNext(item, it)) { 00251 item.item.getText(itemDescription, sizeItemDescription); 00252 item.itemDescription.getText(itemText, sizeItemText); 00253 valid=true; 00254 break; 00255 } else { 00256 it.reset(); 00257 continue; 00258 } 00259 } 00260 00261 it.i &= 0x7F; 00262 it.i |= (index & 0xF) << 7; //0xF == 1111 00263 00264 return index<length; 00265 } 00266 00267 int TimeShiftedEventDescriptor::getReferenceServiceId() const { 00268 return HILO(s->reference_service_id); 00269 } 00270 00271 int TimeShiftedEventDescriptor::getReferenceEventId() const { 00272 return HILO(s->reference_event_id); 00273 } 00274 00275 void TimeShiftedEventDescriptor::Parse() { 00276 s=data.getData<const descr_time_shifted_event>(); 00277 } 00278 00279 void ContentDescriptor::Parse() { 00280 //this descriptor is only a header and a loop 00281 nibbleLoop.setData(data+sizeof(descr_content), getLength()-sizeof(descr_content)); 00282 } 00283 00284 int ContentDescriptor::Nibble::getContentNibbleLevel1() const { 00285 return s->content_nibble_level_1; 00286 } 00287 00288 int ContentDescriptor::Nibble::getContentNibbleLevel2() const { 00289 return s->content_nibble_level_2; 00290 } 00291 00292 int ContentDescriptor::Nibble::getUserNibble1() const { 00293 return s->user_nibble_1; 00294 } 00295 00296 int ContentDescriptor::Nibble::getUserNibble2() const { 00297 return s->user_nibble_2; 00298 } 00299 00300 void ContentDescriptor::Nibble::Parse() { 00301 s=data.getData<const nibble_content>(); 00302 } 00303 00304 void ParentalRatingDescriptor::Parse() { 00305 //this descriptor is only a header and a loop 00306 ratingLoop.setData(data+sizeof(descr_parental_rating), getLength()-sizeof(descr_parental_rating)); 00307 } 00308 00309 int ParentalRatingDescriptor::Rating::getRating() const { 00310 return s->rating; 00311 } 00312 00313 void ParentalRatingDescriptor::Rating::Parse() { 00314 s=data.getData<const parental_rating>(); 00315 languageCode[0]=s->lang_code1; 00316 languageCode[1]=s->lang_code2; 00317 languageCode[2]=s->lang_code3; 00318 languageCode[3]=0; 00319 } 00320 00321 void TeletextDescriptor::Parse() { 00322 //this descriptor is only a header and a loop 00323 teletextLoop.setData(data+sizeof(descr_teletext), getLength()-sizeof(descr_teletext)); 00324 } 00325 00326 void TeletextDescriptor::Teletext::Parse() { 00327 s=data.getData<const item_teletext>(); 00328 languageCode[0]=s->lang_code1; 00329 languageCode[1]=s->lang_code2; 00330 languageCode[2]=s->lang_code3; 00331 languageCode[3]=0; 00332 } 00333 00334 int TeletextDescriptor::Teletext::getTeletextType() const { 00335 return s->type; 00336 } 00337 00338 int TeletextDescriptor::Teletext::getTeletextMagazineNumber() const { 00339 return s->magazine_number; 00340 } 00341 00342 int TeletextDescriptor::Teletext::getTeletextPageNumber() const { 00343 return s->page_number; 00344 } 00345 00346 int CaDescriptor::getCaType() const { 00347 return HILO(s->CA_type); 00348 } 00349 00350 int CaDescriptor::getCaPid() const { 00351 return HILO(s->CA_PID); 00352 } 00353 00354 void CaDescriptor::Parse() { 00355 int offset=0; 00356 data.setPointerAndOffset<const descr_ca>(s, offset); 00357 if (checkSize(getLength()-offset)) 00358 privateData.assign(data.getData(offset), getLength()-offset); 00359 } 00360 00361 int StreamIdentifierDescriptor::getComponentTag() const { 00362 return s->component_tag; 00363 } 00364 00365 void StreamIdentifierDescriptor::Parse() { 00366 s=data.getData<const descr_stream_identifier>(); 00367 } 00368 00369 void NetworkNameDescriptor::Parse() { 00370 name.setData(data+sizeof(descr_network_name), getLength()-sizeof(descr_network_name)); 00371 } 00372 00373 void CaIdentifierDescriptor::Parse() { 00374 identifiers.setData(data+sizeof(descr_ca_identifier), getLength()-sizeof(descr_ca_identifier)); 00375 } 00376 00377 int CarouselIdentifierDescriptor::getCarouselId() const { 00378 return (HILO(s->carousel_id_hi) << 16) | HILO(s->carousel_id_lo); 00379 } 00380 00381 int CarouselIdentifierDescriptor::getFormatId() const { 00382 return s->FormatId; 00383 } 00384 00385 void CarouselIdentifierDescriptor::Parse() { 00386 s=data.getData<const descr_carousel_identifier>(); 00387 } 00388 00389 void ServiceListDescriptor::Parse() { 00390 serviceLoop.setData(data+sizeof(descr_service_list), getLength()-sizeof(descr_service_list)); 00391 } 00392 00393 int ServiceListDescriptor::Service::getServiceId() const { 00394 return HILO(s->service_id); 00395 } 00396 00397 int ServiceListDescriptor::Service::getServiceType() const { 00398 return s->service_type; 00399 } 00400 00401 void ServiceListDescriptor::Service::Parse() { 00402 s=data.getData<const descr_service_list_loop>(); 00403 } 00404 00405 int SatelliteDeliverySystemDescriptor::getFrequency() const { 00406 return (HILO(s->frequency_hi) << 16) | HILO(s->frequency_lo); 00407 } 00408 00409 int SatelliteDeliverySystemDescriptor::getOrbitalPosition() const { 00410 return HILO(s->orbital_position); 00411 } 00412 00413 int SatelliteDeliverySystemDescriptor::getWestEastFlag() const { 00414 return s->west_east_flag; 00415 } 00416 00417 int SatelliteDeliverySystemDescriptor::getPolarization() const { 00418 return s->polarization; 00419 } 00420 00421 int SatelliteDeliverySystemDescriptor::getModulationSystem() const { 00422 return s->modulation_system; 00423 } 00424 00425 int SatelliteDeliverySystemDescriptor::getModulationType() const { 00426 return s->modulation_type; 00427 } 00428 00429 int SatelliteDeliverySystemDescriptor::getRollOff() const { 00430 return s->roll_off; 00431 } 00432 00433 int SatelliteDeliverySystemDescriptor::getSymbolRate() const { 00434 return (HILO(s->symbol_rate_hi) << 12) | (s->symbol_rate_lo_1 << 4) | s->symbol_rate_lo_2; 00435 } 00436 00437 int SatelliteDeliverySystemDescriptor::getFecInner() const { 00438 return s->fec_inner; 00439 } 00440 00441 void SatelliteDeliverySystemDescriptor::Parse() { 00442 s=data.getData<const descr_satellite_delivery_system>(); 00443 } 00444 00445 int CableDeliverySystemDescriptor::getFrequency() const { 00446 return (HILO(s->frequency_hi) << 16) | HILO(s->frequency_lo); 00447 } 00448 00449 int CableDeliverySystemDescriptor::getFecOuter() const { 00450 return s->fec_outer; 00451 } 00452 00453 int CableDeliverySystemDescriptor::getModulation() const { 00454 return s->modulation; 00455 } 00456 00457 int CableDeliverySystemDescriptor::getSymbolRate() const { 00458 return (HILO(s->symbol_rate_hi) << 12) | (s->symbol_rate_lo_1 << 4) | s->symbol_rate_lo_2; 00459 } 00460 00461 int CableDeliverySystemDescriptor::getFecInner() const { 00462 return s->fec_inner; 00463 } 00464 00465 void CableDeliverySystemDescriptor::Parse() { 00466 s=data.getData<const descr_cable_delivery_system>(); 00467 } 00468 00469 int TerrestrialDeliverySystemDescriptor::getFrequency() const { 00470 return (HILO(s->frequency_hi) << 16) | HILO(s->frequency_lo); 00471 } 00472 00473 int TerrestrialDeliverySystemDescriptor::getPriority() const { 00474 return s->priority; 00475 } 00476 00477 int TerrestrialDeliverySystemDescriptor::getTimeSlicingIndicator() const { 00478 return s->time_slicing_indicator; 00479 } 00480 00481 int TerrestrialDeliverySystemDescriptor::getMpeFecIndicator() const { 00482 return s->mpe_fec_indicator; 00483 } 00484 00485 int TerrestrialDeliverySystemDescriptor::getBandwidth() const { 00486 return s->bandwidth; 00487 } 00488 00489 int TerrestrialDeliverySystemDescriptor::getConstellation() const { 00490 return s->constellation; 00491 } 00492 00493 int TerrestrialDeliverySystemDescriptor::getHierarchy() const { 00494 return s->hierarchy; 00495 } 00496 00497 int TerrestrialDeliverySystemDescriptor::getCodeRateHP() const { 00498 return s->code_rate_HP; 00499 } 00500 00501 int TerrestrialDeliverySystemDescriptor::getCodeRateLP() const { 00502 return s->code_rate_LP; 00503 } 00504 00505 int TerrestrialDeliverySystemDescriptor::getGuardInterval() const { 00506 return s->guard_interval; 00507 } 00508 00509 int TerrestrialDeliverySystemDescriptor::getTransmissionMode() const { 00510 return s->transmission_mode; 00511 } 00512 00513 bool TerrestrialDeliverySystemDescriptor::getOtherFrequency() const { 00514 return s->other_frequency_flag; 00515 } 00516 00517 void TerrestrialDeliverySystemDescriptor::Parse() { 00518 s=data.getData<const descr_terrestrial_delivery>(); 00519 } 00520 00521 int ServiceDescriptor::getServiceType() const { 00522 return s->service_type; 00523 } 00524 00525 void ServiceDescriptor::Parse() { 00526 int offset=0; 00527 data.setPointerAndOffset<const descr_service>(s, offset); 00528 providerName.setDataAndOffset(data+offset, s->provider_name_length, offset); 00529 const descr_service_mid *mid; 00530 data.setPointerAndOffset<const descr_service_mid>(mid, offset); 00531 serviceName.setData(data+offset, mid->service_name_length); 00532 } 00533 00534 void NVODReferenceDescriptor::Parse() { 00535 serviceLoop.setData(data+sizeof(descr_nvod_reference), getLength()-sizeof(descr_nvod_reference)); 00536 } 00537 00538 int NVODReferenceDescriptor::Service::getTransportStream() const { 00539 return HILO(s->transport_stream_id); 00540 } 00541 00542 int NVODReferenceDescriptor::Service::getOriginalNetworkId() const { 00543 return HILO(s->original_network_id); 00544 } 00545 00546 int NVODReferenceDescriptor::Service::getServiceId() const { 00547 return HILO(s->service_id); 00548 } 00549 00550 void NVODReferenceDescriptor::Service::Parse() { 00551 s=data.getData<const item_nvod_reference>(); 00552 } 00553 00554 int TimeShiftedServiceDescriptor::getReferenceServiceId() const { 00555 return HILO(s->reference_service_id); 00556 } 00557 00558 void TimeShiftedServiceDescriptor::Parse() { 00559 s=data.getData<const descr_time_shifted_service>(); 00560 } 00561 00562 int ComponentDescriptor::getStreamContent() const { 00563 return s->stream_content; 00564 } 00565 00566 int ComponentDescriptor::getComponentType() const { 00567 return s->component_type; 00568 } 00569 00570 int ComponentDescriptor::getComponentTag() const { 00571 return s->component_tag; 00572 } 00573 00574 void ComponentDescriptor::Parse() { 00575 int offset=0; 00576 data.setPointerAndOffset<const descr_component>(s, offset); 00577 languageCode[0]=s->lang_code1; 00578 languageCode[1]=s->lang_code2; 00579 languageCode[2]=s->lang_code3; 00580 languageCode[3]=0; 00581 description.setData(data+offset, getLength()-offset); 00582 } 00583 00584 void PrivateDataSpecifierDescriptor::Parse() { 00585 s=data.getData<const descr_private_data_specifier>(); 00586 } 00587 00588 int PrivateDataSpecifierDescriptor::getPrivateDataSpecifier() const { 00589 return (HILO(s->private_data_specifier_hi) << 16) | HILO(s->private_data_specifier_lo); 00590 } 00591 00592 void SubtitlingDescriptor::Parse() { 00593 subtitlingLoop.setData(data+sizeof(descr_subtitling), getLength()-sizeof(descr_subtitling)); 00594 } 00595 00596 int SubtitlingDescriptor::Subtitling::getSubtitlingType() const { 00597 return s->subtitling_type; 00598 } 00599 00600 int SubtitlingDescriptor::Subtitling::getCompositionPageId() const { 00601 return HILO(s->composition_page_id); 00602 } 00603 00604 int SubtitlingDescriptor::Subtitling::getAncillaryPageId() const { 00605 return HILO(s->ancillary_page_id); 00606 } 00607 00608 void SubtitlingDescriptor::Subtitling::Parse() { 00609 s=data.getData<const item_subtitling>(); 00610 languageCode[0]=s->lang_code1; 00611 languageCode[1]=s->lang_code2; 00612 languageCode[2]=s->lang_code3; 00613 languageCode[3]=0; 00614 } 00615 00616 int ServiceMoveDescriptor::getNewOriginalNetworkId() const { 00617 return HILO(s->new_original_network_id); 00618 } 00619 00620 int ServiceMoveDescriptor::getNewTransportStreamId() const { 00621 return HILO(s->new_transport_stream_id); 00622 } 00623 00624 int ServiceMoveDescriptor::getNewServiceId() const { 00625 return HILO(s->new_service_id); 00626 } 00627 00628 void ServiceMoveDescriptor::Parse() { 00629 s=data.getData<const descr_service_move>(); 00630 } 00631 00632 int FrequencyListDescriptor::getCodingType() const { 00633 return s->coding_type; 00634 } 00635 00636 void FrequencyListDescriptor::Parse() { 00637 int offset=0; 00638 data.setPointerAndOffset<const descr_frequency_list>(s, offset); 00639 frequencies.setData(data+offset, getLength()-offset); 00640 } 00641 00642 void ServiceIdentifierDescriptor::Parse() { 00643 textualServiceIdentifier.setData(data+sizeof(descr_service_identifier), getLength()-sizeof(descr_service_identifier)); 00644 } 00645 00646 void ContentIdentifierDescriptor::Parse() { 00647 identifierLoop.setData(data+sizeof(descr_content_identifier), getLength()-sizeof(descr_content_identifier)); 00648 } 00649 00650 void ContentIdentifierDescriptor::Identifier::Parse() { 00651 int offset=0; 00652 data.setPointerAndOffset<const content_identifier_entry>(s, offset); 00653 if (s->crid_location == 0) { 00654 identifier.setData(data+(offset-1), s->crid_length); 00655 } 00656 else { 00657 identifier.setData(data+(offset-1), 2); 00658 } 00659 } 00660 00661 int ContentIdentifierDescriptor::Identifier::getCridType() const { 00662 return s->crid_type; 00663 } 00664 00665 int ContentIdentifierDescriptor::Identifier::getCridLocation() const { 00666 return s->crid_location; 00667 } 00668 00669 void DefaultAuthorityDescriptor::Parse() { 00670 DefaultAuthority.setData(data+sizeof(descr_default_authority), getLength()-sizeof(descr_default_authority)); 00671 } 00672 00673 void MultilingualNameDescriptor::Parse() { 00674 nameLoop.setData(data+sizeof(descr_multilingual_network_name), getLength()-sizeof(descr_multilingual_network_name)); 00675 } 00676 00677 void MultilingualNameDescriptor::Name::Parse() { 00678 int offset=0; 00679 const entry_multilingual_name *s; 00680 data.setPointerAndOffset<const entry_multilingual_name>(s, offset); 00681 languageCode[0]=s->lang_code1; 00682 languageCode[1]=s->lang_code2; 00683 languageCode[2]=s->lang_code3; 00684 languageCode[3]=0; 00685 name.setData(data+offset, s->text_length); 00686 } 00687 00688 int MultilingualComponentDescriptor::getComponentTag() const { 00689 return s->component_tag; 00690 } 00691 00692 void MultilingualComponentDescriptor::Parse() { 00693 int offset=0; 00694 data.setPointerAndOffset<const descr_multilingual_component>(s, offset); 00695 nameLoop.setData(data+sizeof(descr_multilingual_component), getLength()-sizeof(descr_multilingual_component)); 00696 } 00697 00698 void MultilingualServiceNameDescriptor::Parse() { 00699 nameLoop.setData(data+sizeof(descr_multilingual_network_name), getLength()-sizeof(descr_multilingual_network_name)); 00700 } 00701 00702 void MultilingualServiceNameDescriptor::Name::Parse() { 00703 int offset=0; 00704 const entry_multilingual_name *s; 00705 data.setPointerAndOffset<const entry_multilingual_name>(s, offset); 00706 languageCode[0]=s->lang_code1; 00707 languageCode[1]=s->lang_code2; 00708 languageCode[2]=s->lang_code3; 00709 languageCode[3]=0; 00710 providerName.setDataAndOffset(data+offset, s->text_length, offset); 00711 const entry_multilingual_service_name_mid *mid; 00712 data.setPointerAndOffset<const entry_multilingual_service_name_mid>(mid, offset); 00713 name.setData(data+offset, mid->service_name_length); 00714 } 00715 00716 void LocalTimeOffsetDescriptor::Parse() { 00717 localTimeOffsetLoop.setData(data+sizeof(descr_local_time_offset), getLength()-sizeof(descr_local_time_offset)); 00718 } 00719 00720 int LocalTimeOffsetDescriptor::LocalTimeOffset::getCountryId() const { 00721 return s->country_region_id; 00722 } 00723 00724 int LocalTimeOffsetDescriptor::LocalTimeOffset::getLocalTimeOffsetPolarity() const { 00725 return s->local_time_offset_polarity; 00726 } 00727 00728 int LocalTimeOffsetDescriptor::LocalTimeOffset::getLocalTimeOffset() const { 00729 return (s->local_time_offset_h << 8) | s->local_time_offset_m; 00730 } 00731 00732 time_t LocalTimeOffsetDescriptor::LocalTimeOffset::getTimeOfChange() const { 00733 return DVBTime::getTime(s->time_of_change_mjd_hi, s->time_of_change_mjd_lo, s->time_of_change_time_h, s->time_of_change_time_m, s->time_of_change_time_s); 00734 } 00735 00736 int LocalTimeOffsetDescriptor::LocalTimeOffset::getNextTimeOffset() const { 00737 return (s->next_time_offset_h << 8) | s->next_time_offset_m; 00738 } 00739 00740 void LocalTimeOffsetDescriptor::LocalTimeOffset::Parse() { 00741 s=data.getData<const local_time_offset_entry>(); 00742 countryCode[0]=s->country_code1; 00743 countryCode[1]=s->country_code2; 00744 countryCode[2]=s->country_code3; 00745 countryCode[3]=0; 00746 } 00747 00748 void LinkageDescriptor::Parse() { 00749 int offset=0; 00750 s1 = NULL; 00751 data.setPointerAndOffset<const descr_linkage>(s, offset); 00752 if (checkSize(getLength()-offset)) { 00753 if (getLinkageType() == LinkageTypeMobileHandover) 00754 data.setPointerAndOffset<const descr_linkage_8>(s1, offset); 00755 privateData.assign(data.getData(offset), getLength()-offset); 00756 } 00757 } 00758 00759 int LinkageDescriptor::getTransportStreamId() const { 00760 return HILO(s->transport_stream_id); 00761 } 00762 00763 int LinkageDescriptor::getOriginalNetworkId() const { 00764 return HILO(s->original_network_id); 00765 } 00766 00767 int LinkageDescriptor::getServiceId() const { 00768 return HILO(s->service_id); 00769 } 00770 00771 LinkageType LinkageDescriptor::getLinkageType() const { 00772 return (LinkageType)s->linkage_type; 00773 } 00774 00775 int LinkageDescriptor::getHandOverType() const { 00776 return s1 == NULL ? 0 : s1->hand_over_type; 00777 } 00778 00779 int LinkageDescriptor::getOriginType() const { 00780 return s1 == NULL ? 0 : s1->origin_type; 00781 } 00782 00783 int LinkageDescriptor::getId() const { 00784 return s1 == NULL ? 0 : HILO(s1->id); 00785 } 00786 00787 void ISO639LanguageDescriptor::Parse() { 00788 languageLoop.setData(data+sizeof(descr_iso_639_language), getLength()-sizeof(descr_iso_639_language)); 00789 00790 //all this is for backwards compatibility only 00791 Loop::Iterator it; 00792 Language first; 00793 if (languageLoop.getNext(first, it)) { 00794 languageCode[0]=first.languageCode[0]; 00795 languageCode[1]=first.languageCode[1]; 00796 languageCode[2]=first.languageCode[2]; 00797 languageCode[3]=0; 00798 } else 00799 languageCode[0]=0; 00800 } 00801 00802 void ISO639LanguageDescriptor::Language::Parse() { 00803 s=data.getData<const descr_iso_639_language_loop>(); 00804 languageCode[0]=s->lang_code1; 00805 languageCode[1]=s->lang_code2; 00806 languageCode[2]=s->lang_code3; 00807 languageCode[3]=0; 00808 } 00809 00810 AudioType ISO639LanguageDescriptor::Language::getAudioType() { 00811 return (AudioType)s->audio_type; 00812 } 00813 00814 void PDCDescriptor::Parse() { 00815 int offset=0; 00816 data.setPointerAndOffset<const descr_pdc>(s, offset); 00817 } 00818 00819 int PDCDescriptor::getDay() const { 00820 return ((s->pil0 & 0x0F) << 1) | ((s->pil1 & 0x80) >> 7); 00821 } 00822 00823 int PDCDescriptor::getMonth() const { 00824 return (s->pil1 >> 3) & 0x0F; 00825 } 00826 00827 int PDCDescriptor::getHour() const { 00828 return ((s->pil1 & 0x07) << 2) | ((s->pil2 & 0xC0) >> 6); 00829 } 00830 00831 int PDCDescriptor::getMinute() const { 00832 return s->pil2 & 0x3F; 00833 } 00834 00835 void AncillaryDataDescriptor::Parse() { 00836 int offset=0; 00837 data.setPointerAndOffset<const descr_ancillary_data>(s, offset); 00838 } 00839 00840 int AncillaryDataDescriptor::getAncillaryDataIdentifier() const { 00841 return s->ancillary_data_identifier; 00842 } 00843 00844 void S2SatelliteDeliverySystemDescriptor::Parse() { 00845 int offset=0; 00846 input_stream_identifier=0; 00847 data.setPointerAndOffset<const descr_s2_satellite_delivery_system>(s, offset); 00848 if (s->scrambling_sequence_selector) 00849 data.setPointerAndOffset<const descr_scrambling_sequence_selector>(sss, offset); 00850 if (s->multiple_input_stream_flag) 00851 input_stream_identifier = *data.getData(offset++); 00852 } 00853 00854 int S2SatelliteDeliverySystemDescriptor::getScramblingSequenceSelector() const { 00855 return s->scrambling_sequence_selector; 00856 } 00857 00858 int S2SatelliteDeliverySystemDescriptor::getMultipleInputStreamFlag() const { 00859 return s->multiple_input_stream_flag; 00860 } 00861 00862 int S2SatelliteDeliverySystemDescriptor::getBackwardsCompatibilityIndicator() const { 00863 return s->backwards_compatibility_indicator; 00864 } 00865 00866 int S2SatelliteDeliverySystemDescriptor::getScramblingSequenceIndex() const { 00867 return sss == NULL ? 0 : (sss->scrambling_sequence_index_hi_lo << 16) | HILO(sss->scrambling_sequence_index_lo); 00868 } 00869 00870 void ExtensionDescriptor::Parse() { 00871 int offset=0; 00872 data.setPointerAndOffset<const descr_extension>(s, offset); 00873 } 00874 00875 int ExtensionDescriptor::getExtensionDescriptorTag() const { 00876 return s->descriptor_tag_extension; 00877 } 00878 00879 void T2DeliverySystemDescriptor::Parse() { 00880 int offset=0; 00881 data.setPointerAndOffset<const descr_t2_delivery_system>(s, offset); 00882 extended_data_flag = s->descriptor_length > 0x04; 00883 } 00884 00885 int T2DeliverySystemDescriptor::getExtendedDataFlag() const { 00886 return extended_data_flag; 00887 } 00888 00889 int T2DeliverySystemDescriptor::getExtensionDescriptorTag() const { 00890 return s->descriptor_tag_extension; 00891 } 00892 00893 int T2DeliverySystemDescriptor::getPlpId() const { 00894 return s->plp_id; 00895 } 00896 00897 int T2DeliverySystemDescriptor::getT2SystemId() const { 00898 return HILO(s->t2_system_id); 00899 } 00900 00901 int T2DeliverySystemDescriptor::getSisoMiso() const { 00902 return extended_data_flag ? s->siso_miso : -1; 00903 } 00904 00905 int T2DeliverySystemDescriptor::getBandwidth() const { 00906 return extended_data_flag ? s->bandwidth : -1; 00907 } 00908 00909 int T2DeliverySystemDescriptor::getGuardInterval() const { 00910 return extended_data_flag ? s->guard_interval : -1; 00911 } 00912 00913 int T2DeliverySystemDescriptor::getTransmissionMode() const { 00914 return extended_data_flag ? s->transmission_mode : -1; 00915 } 00916 00917 int T2DeliverySystemDescriptor::getOtherFrequencyFlag() const { 00918 return extended_data_flag ? s->other_frequency_flag : -1; 00919 } 00920 00921 int T2DeliverySystemDescriptor::getTfsFlag() const { 00922 return extended_data_flag ? s->tfs_flag : -1; 00923 } 00924 00925 int PremiereContentTransmissionDescriptor::getOriginalNetworkId() const { 00926 return HILO(s->original_network_id); 00927 } 00928 00929 int PremiereContentTransmissionDescriptor::getTransportStreamId() const { 00930 return HILO(s->transport_stream_id); 00931 } 00932 00933 int PremiereContentTransmissionDescriptor::getServiceId() const { 00934 return HILO(s->service_id); 00935 } 00936 00937 void PremiereContentTransmissionDescriptor::Parse() { 00938 s=data.getData<const descr_premiere_content_transmission>(); 00939 startDayLoop.setData(data+sizeof(descr_premiere_content_transmission), getLength()-sizeof(descr_premiere_content_transmission)); 00940 } 00941 00942 int PremiereContentTransmissionDescriptor::StartDayEntry::getMJD() const { 00943 return HILO(s->mjd); 00944 } 00945 00946 int PremiereContentTransmissionDescriptor::StartDayEntry::getLoopLength() const { 00947 return s->start_time_loop; 00948 } 00949 00950 int PremiereContentTransmissionDescriptor::StartDayEntry::getLength() { 00951 return sizeof(item_premiere_content_transmission_day)+getLoopLength(); 00952 } 00953 00954 void PremiereContentTransmissionDescriptor::StartDayEntry::Parse() { 00955 s=data.getData<const item_premiere_content_transmission_day>(); 00956 startTimeLoop.setData(data+sizeof(item_premiere_content_transmission_day), getLoopLength()); 00957 } 00958 00959 time_t PremiereContentTransmissionDescriptor::StartDayEntry::StartTimeEntry::getStartTime(int mjd) const { 00960 return DVBTime::getTime(mjd >> 8, mjd & 0xff, s->start_time_h, s->start_time_m, s->start_time_s); 00961 } 00962 00963 void PremiereContentTransmissionDescriptor::StartDayEntry::StartTimeEntry::Parse() { 00964 s=data.getData<const item_premiere_content_transmission_time>(); 00965 } 00966 00967 void ApplicationSignallingDescriptor::Parse() { 00968 entryLoop.setData(data+sizeof(descr_application_signalling), getLength()-sizeof(descr_application_signalling)); 00969 } 00970 00971 int ApplicationSignallingDescriptor::ApplicationEntryDescriptor::getApplicationType() const { 00972 return HILO(s->application_type); 00973 } 00974 00975 int ApplicationSignallingDescriptor::ApplicationEntryDescriptor::getAITVersionNumber() const { 00976 return s->AIT_version_number; 00977 } 00978 00979 void ApplicationSignallingDescriptor::ApplicationEntryDescriptor::Parse() { 00980 s=data.getData<const application_signalling_entry>(); 00981 } 00982 00983 bool MHP_ApplicationDescriptor::isServiceBound() const { 00984 return s->service_bound_flag; 00985 } 00986 00987 int MHP_ApplicationDescriptor::getVisibility() const { 00988 return s->visibility; 00989 } 00990 00991 int MHP_ApplicationDescriptor::getApplicationPriority() const { 00992 return s->application_priority; 00993 } 00994 00995 void MHP_ApplicationDescriptor::Parse() { 00996 int offset=0; 00997 const descr_application *dapp; 00998 data.setPointerAndOffset<const descr_application>(dapp, offset); 00999 profileLoop.setDataAndOffset(data+offset, dapp->application_profiles_length, offset); 01000 data.setPointerAndOffset<const descr_application_end>(s, offset); 01001 transportProtocolLabels.setData(data+offset, getLength()-offset); 01002 } 01003 01004 int MHP_ApplicationDescriptor::Profile::getApplicationProfile() const { 01005 return HILO(s->application_profile); 01006 } 01007 01008 int MHP_ApplicationDescriptor::Profile::getVersionMajor() const { 01009 return s->version_major; 01010 } 01011 01012 int MHP_ApplicationDescriptor::Profile::getVersionMinor() const { 01013 return s->version_minor; 01014 } 01015 01016 int MHP_ApplicationDescriptor::Profile::getVersionMicro() const { 01017 return s->version_micro; 01018 } 01019 01020 void MHP_ApplicationDescriptor::Profile::Parse() { 01021 s=data.getData<application_profile_entry>(); 01022 } 01023 01024 void MHP_ApplicationNameDescriptor::Parse() { 01025 nameLoop.setData(data+sizeof(descr_application_name), getLength()-sizeof(descr_application_name)); 01026 } 01027 01028 void MHP_ApplicationNameDescriptor::NameEntry::Parse() { 01029 const descr_application_name_entry *s; 01030 s=data.getData<const descr_application_name_entry>(); 01031 name.setData(data+sizeof(descr_application_name_entry), s->application_name_length); 01032 languageCode[0]=s->lang_code1; 01033 languageCode[1]=s->lang_code2; 01034 languageCode[2]=s->lang_code3; 01035 languageCode[3]=0; 01036 } 01037 01038 int MHP_TransportProtocolDescriptor::getProtocolId() const { 01039 return HILO(s->protocol_id); 01040 } 01041 01042 int MHP_TransportProtocolDescriptor::getProtocolLabel() const { 01043 return s->transport_protocol_label; 01044 } 01045 01046 bool MHP_TransportProtocolDescriptor::isRemote() const { 01047 return remote; 01048 } 01049 01050 int MHP_TransportProtocolDescriptor::getComponentTag() const { 01051 return componentTag; 01052 } 01053 01054 char *MHP_TransportProtocolDescriptor::getUrlBase(char *buffer, int size) { 01055 return UrlBase.getText(buffer, size); 01056 } 01057 01058 void MHP_TransportProtocolDescriptor::Parse() { 01059 int offset=0; 01060 remote=false; 01061 componentTag=-1; 01062 data.setPointerAndOffset<const descr_transport_protocol>(s, offset); 01063 if (getProtocolId() == ObjectCarousel) { 01064 const transport_via_oc *oc; 01065 data.setPointerAndOffset<const transport_via_oc>(oc, offset); 01066 remote=oc->remote; 01067 if (remote) { 01068 const transport_via_oc_remote_end *rem; 01069 data.setPointerAndOffset<const transport_via_oc_remote_end>(rem, offset); 01070 componentTag=rem->component_tag; 01071 } else { 01072 const transport_via_oc_end *rem; 01073 data.setPointerAndOffset<const transport_via_oc_end>(rem, offset); 01074 componentTag=rem->component_tag; 01075 } 01076 } else if (getProtocolId() == HTTPoverInteractionChannel) { 01077 const transport_via_http *http; 01078 data.setPointerAndOffset<const transport_via_http>(http, offset); 01079 UrlBase.setDataAndOffset(data+offset, http->url_base_length, offset); 01080 01081 // fill URL Extension, 01082 UrlExtensionLoop.setData(data+offset, getLength()-offset); 01083 } else { 01084 //unimplemented 01085 } 01086 } 01087 01088 void MHP_TransportProtocolDescriptor::UrlExtensionEntry::Parse() { 01089 const descr_url_extension_entry *s; 01090 s=data.getData<const descr_url_extension_entry>(); 01091 UrlExtension.setData(data, s->url_extension_length); 01092 } 01093 01094 void MHP_DVBJApplicationDescriptor::Parse() { 01095 applicationLoop.setData(data+sizeof(descr_dvbj_application), getLength()-sizeof(descr_dvbj_application)); 01096 } 01097 01098 void MHP_DVBJApplicationDescriptor::ApplicationEntry::Parse() { 01099 const descr_dvbj_application_entry *entry=data.getData<const descr_dvbj_application_entry>(); 01100 parameter.setData(data+sizeof(descr_dvbj_application_entry), entry->parameter_length); 01101 } 01102 01103 void MHP_DVBJApplicationLocationDescriptor::Parse() { 01104 int offset=0; 01105 const descr_dvbj_application_location *first; 01106 data.setPointerAndOffset<const descr_dvbj_application_location>(first, offset); 01107 baseDirectory.setDataAndOffset(data+offset, first->base_directory_length, offset); 01108 const descr_dvbj_application_location_mid *mid; 01109 data.setPointerAndOffset<const descr_dvbj_application_location_mid>(mid, offset); 01110 classPath.setDataAndOffset(data+offset, mid->classpath_extension_length, offset); 01111 initialClass.setData(data+offset, getLength()-offset); 01112 } 01113 01114 int MHP_ApplicationIconsDescriptor::getIconFlags() const { 01115 return HILO(s->icon_flags); 01116 } 01117 01118 void MHP_ApplicationIconsDescriptor::Parse() { 01119 int offset=0; 01120 const descr_application_icons_descriptor *first; 01121 data.setPointerAndOffset<const descr_application_icons_descriptor>(first, offset); 01122 iconLocator.setDataAndOffset(data+offset, first->icon_locator_length, offset); 01123 data.setPointerAndOffset<const descr_application_icons_descriptor_end>(s, offset); 01124 } 01125 01126 char *MHP_SimpleApplicationLocationDescriptor::getLocation(char *buffer, int size) { 01127 return location.getText(buffer, size); 01128 } 01129 01130 void MHP_SimpleApplicationLocationDescriptor::Parse() { 01131 int offset=0; 01132 const descr_simple_application_location_descriptor *loc; 01133 data.setPointerAndOffset<const descr_simple_application_location_descriptor>(loc, offset); 01134 location.setDataAndOffset(data+offset, loc->descriptor_length, offset); 01135 } 01136 01137 int RegistrationDescriptor::getFormatIdentifier() const { 01138 return HILOHILO(s->format_identifier); 01139 } 01140 01141 void RegistrationDescriptor::Parse() { 01142 int offset=0; 01143 data.setPointerAndOffset<const descr_registration>(s, offset); 01144 if (checkSize(getLength()-offset)) 01145 privateData.assign(data.getData(offset), getLength()-offset); 01146 } 01147 01148 } //end of namespace