vdr  1.7.27
descriptor.c
Go to the documentation of this file.
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