vdr  2.6.9
descriptor.c
Go to the documentation of this file.
1 /***************************************************************************
2  * Copyright (c) 2003 by Marcel Wiesweg *
3  * *
4  * This program is free software; you can redistribute it and/or modify *
5  * it under the terms of the GNU General Public License as published by *
6  * the Free Software Foundation; either version 2 of the License, or *
7  * (at your option) any later version. *
8  * *
9  * $Id: descriptor.c 4.4 2020/12/17 12:52:57 kls Exp $
10  * *
11  ***************************************************************************/
12 
13 #include <string.h>
14 #include "descriptor.h"
15 
16 namespace SI {
17 
19  int offset=0;
20  const descr_short_event *s;
21  data.setPointerAndOffset<const descr_short_event>(s, offset);
25  languageCode[3]=0;
26  name.setDataAndOffset(data+offset, s->event_name_length, offset);
27  const descr_short_event_mid *mid;
29  text.setData(data+offset, mid->text_length);
30 }
31 
33  return s->descriptor_number;
34 }
35 
37  return s->last_descriptor_number;
38 }
39 
41  int offset=0;
46  languageCode[3]=0;
47  itemLoop.setDataAndOffset(data+offset, s->length_of_items, offset);
48  const descr_extended_event_mid *mid;
50  text.setData(data+offset, mid->text_length);
51 }
52 
54  int offset=0;
55  const item_extended_event *first;
56  data.setPointerAndOffset<const item_extended_event>(first, offset);
58  const item_extended_event_mid *mid;
60  item.setData(data+offset, mid->item_length);
61 }
62 
63 /*int ExtendedEventDescriptors::getTextLength() {
64  int ret=0;
65  for (int i=0;i<length;i++) {
66  ExtendedEventDescriptor *d=(ExtendedEventDescriptor *)array[i];
67  if (!d)
68  continue;
69  ret+=d->text.getLength();
70  ExtendedEventDescriptor::Item item;
71  for (Loop::Iterator it; d->itemLoop.hasNext(it); ) {
72  item=d->itemLoop.getNext(it);
73  ret+=item.item.getLength();
74  ret+=item.itemDescription.getLength();
75  ret+=2; //the blanks
76  }
77  }
78  return ret;
79 }*/
80 
81 int ExtendedEventDescriptors::getMaximumTextLength(const char *separation1, const char *separation2) {
82  //add length of plain text, of itemized text with separators, and for one separator between the two fields.
83  return getMaximumTextPlainLength()+getMaximumTextItemizedLength(separation1, separation2)+strlen(separation2);
84 }
85 
86 char *ExtendedEventDescriptors::getText(const char *separation1, const char *separation2) {
87  int size = getMaximumTextLength(separation1, separation2);
88  char *text=new char[size];
89  return getText(text, size, separation1, separation2);
90 }
91 
92 char *ExtendedEventDescriptors::getText(char *buffer, int size, const char *separation1, const char *separation2) {
93  int tmpsize = size;
94  char tmpbuf[tmpsize];
95  const char *fromCode = NULL;
96  int index=0, len;
97  *tmpbuf = 0; // just in case length is 0
98  for (int i=0;i<length;i++) {
100  if (!d)
101  continue;
102  d->text.getText(tmpbuf+index, tmpsize, &fromCode);
103  len = strlen(tmpbuf+index);
104  index += len;
105  tmpsize -= len;
106  }
107  index = convertCharacterTable(tmpbuf, strlen(tmpbuf), buffer, size, fromCode);
108  size -= index;
109  int sepLen1 = strlen(separation1);
110  int sepLen2 = strlen(separation2);
111  bool separated = false;
112  for (int i=0;i<length;i++) {
114  if (!d)
115  continue;
116 
118  for (Loop::Iterator it; d->itemLoop.getNext(item, it); ) {
119  if (!separated && size > sepLen2) {
120  strcpy(buffer+index, separation2); // let's have a separator between the long text and the items
121  index += sepLen2;
122  size -= sepLen2;
123  separated = true;
124  }
125 
126  item.itemDescription.getText(buffer+index, size);
127  len = strlen(buffer+index);
128  index += len;
129  size -= len;
130  if (size > sepLen1) {
131  strcpy(buffer+index, separation1);
132  index += sepLen1;
133  size -= sepLen1;
134  }
135 
136  item.item.getText(buffer+index, size);
137  len = strlen(buffer+index);
138  index += len;
139  size -= len;
140  if (size > sepLen2) {
141  strcpy(buffer+index, separation2);
142  index += sepLen2;
143  size -= sepLen2;
144  }
145  }
146  }
147 
148  buffer[index]='\0';
149  return buffer;
150 }
151 
153  int ret=0;
154  for (int i=0;i<length;i++) {
156  if (!d)
157  continue;
158  ret+=d->text.getLength();
159  }
160  return ret;
161 }
162 
164  int size = getMaximumTextPlainLength();
165  char *text=new char[size];
166  return getTextPlain(text, size);
167 }
168 
169 char *ExtendedEventDescriptors::getTextPlain(char *buffer, int size) {
170  int index=0, len;
171  for (int i=0;i<length;i++) {
173  if (!d)
174  continue;
175  d->text.getText(buffer+index, size);
176  len = strlen(buffer+index);
177  index += len;
178  size -= len;
179  }
180  buffer[index]='\0';
181  return buffer;
182 }
183 
184 int ExtendedEventDescriptors::getMaximumTextItemizedLength(const char *separation1, const char *separation2) {
185  int ret=0;
186  int sepLength=strlen(separation1)+strlen(separation2);
187  for (int i=0;i<length;i++) {
189  if (!d)
190  continue;
191  //The length includes two 8-bit length fields which have already been subtracted from sepLength //XXX kls 2004-06-06: what does this mean???
192  ret+=d->itemLoop.getLength()+sepLength;
193  }
194  return ret;
195 }
196 
197 char *ExtendedEventDescriptors::getTextItemized(const char *separation1, const char *separation2) {
198  int size = getMaximumTextItemizedLength(separation1, separation2);
199  char *text=new char[size];
200  return getTextItemized(text, size, separation1, separation2);
201 }
202 
203 char *ExtendedEventDescriptors::getTextItemized(char *buffer, int size, const char *separation1, const char *separation2) {
204  int index=0, len;
205  int sepLen1 = strlen(separation1);
206  int sepLen2 = strlen(separation2);
207  for (int i=0;i<length;i++) {
209  if (!d)
210  continue;
211 
213  for (Loop::Iterator it; d->itemLoop.getNext(item, it); ) {
214  item.itemDescription.getText(buffer+index, size);
215  len = strlen(buffer+index);
216  index += len;
217  size -= len;
218  if (size > sepLen1) {
219  strcpy(buffer+index, separation1);
220  index += sepLen1;
221  size -= sepLen1;
222  }
223 
224  item.item.getText(buffer+index, size);
225  len = strlen(buffer+index);
226  index += len;
227  size -= len;
228  if (size > sepLen2) {
229  strcpy(buffer+index, separation2);
230  index += sepLen2;
231  size -= sepLen2;
232  }
233  }
234  }
235  buffer[index]='\0';
236  return buffer;
237 }
238 
239 //returns the itemized text pair by pair. Maximum length for buffers is 256.
240 //Return value is false if and only if the end of the list is reached.
241 bool ExtendedEventDescriptors::getTextItemized(Loop::Iterator &it, bool &valid, char *itemDescription, char *itemText, int sizeItemDescription, int sizeItemText) {
242  //The iterator has to store two values: The descriptor index (4bit)
243  //and the item loop index (max overall length 256, min item length 16 => max number 128 => 7bit)
244  valid=false;
245 
246  int index=(it.i & 0x780) >> 7; // 0x780 == 1111 000 0000
247  it.i &= 0x7F; //0x7F == 111 1111
248 
249  for (;index<length;index++) {
251  if (!d)
252  continue;
253 
255  if (d->itemLoop.getNext(item, it)) {
256  item.item.getText(itemDescription, sizeItemDescription);
257  item.itemDescription.getText(itemText, sizeItemText);
258  valid=true;
259  break;
260  } else {
261  it.reset();
262  continue;
263  }
264  }
265 
266  it.i &= 0x7F;
267  it.i |= (index & 0xF) << 7; //0xF == 1111
268 
269  return index<length;
270 }
271 
273  return HILO(s->reference_service_id);
274 }
275 
277  return HILO(s->reference_event_id);
278 }
279 
282 }
283 
285  //this descriptor is only a header and a loop
286  nibbleLoop.setData(data+sizeof(descr_content), getLength()-sizeof(descr_content));
287 }
288 
290  return s->content_nibble_level_1;
291 }
292 
294  return s->content_nibble_level_2;
295 }
296 
298  return s->user_nibble_1;
299 }
300 
302  return s->user_nibble_2;
303 }
304 
306  s=data.getData<const nibble_content>();
307 }
308 
310  //this descriptor is only a header and a loop
311  ratingLoop.setData(data+sizeof(descr_parental_rating), getLength()-sizeof(descr_parental_rating));
312 }
313 
315  return s->rating;
316 }
317 
319  s=data.getData<const parental_rating>();
323  languageCode[3]=0;
324 }
325 
327  //this descriptor is only a header and a loop
328  teletextLoop.setData(data+sizeof(descr_teletext), getLength()-sizeof(descr_teletext));
329 }
330 
332  s=data.getData<const item_teletext>();
336  languageCode[3]=0;
337 }
338 
340  return s->type;
341 }
342 
344  return s->magazine_number;
345 }
346 
348  return s->page_number;
349 }
350 
352  return HILO(s->CA_type);
353 }
354 
356  return HILO(s->CA_PID);
357 }
358 
360  int offset=0;
361  data.setPointerAndOffset<const descr_ca>(s, offset);
362  if (checkSize(getLength()-offset))
363  privateData.assign(data.getData(offset), getLength()-offset);
364 }
365 
367  return s->component_tag;
368 }
369 
372 }
373 
375  name.setData(data+sizeof(descr_network_name), getLength()-sizeof(descr_network_name));
376 }
377 
379  identifiers.setData(data+sizeof(descr_ca_identifier), getLength()-sizeof(descr_ca_identifier));
380 }
381 
383  return (HILO(s->carousel_id_hi) << 16) | HILO(s->carousel_id_lo);
384 }
385 
387  return s->FormatId;
388 }
389 
392 }
393 
395  serviceLoop.setData(data+sizeof(descr_service_list), getLength()-sizeof(descr_service_list));
396 }
397 
399  return HILO(s->service_id);
400 }
401 
403  return s->service_type;
404 }
405 
408 }
409 
411  return (HILO(s->frequency_hi) << 16) | HILO(s->frequency_lo);
412 }
413 
415  return HILO(s->orbital_position);
416 }
417 
419  return s->west_east_flag;
420 }
421 
423  return s->polarization;
424 }
425 
427  return s->modulation_system;
428 }
429 
431  return s->modulation_type;
432 }
433 
435  return s->roll_off;
436 }
437 
439  return (HILO(s->symbol_rate_hi) << 12) | (s->symbol_rate_lo_1 << 4) | s->symbol_rate_lo_2;
440 }
441 
443  return s->fec_inner;
444 }
445 
448 }
449 
451  return (HILO(s->frequency_hi) << 16) | HILO(s->frequency_lo);
452 }
453 
455  return s->fec_outer;
456 }
457 
459  return s->modulation;
460 }
461 
463  return (HILO(s->symbol_rate_hi) << 12) | (s->symbol_rate_lo_1 << 4) | s->symbol_rate_lo_2;
464 }
465 
467  return s->fec_inner;
468 }
469 
472 }
473 
475  return (HILO(s->frequency_hi) << 16) | HILO(s->frequency_lo);
476 }
477 
479  return s->priority;
480 }
481 
483  return s->time_slicing_indicator;
484 }
485 
487  return s->mpe_fec_indicator;
488 }
489 
491  return s->bandwidth;
492 }
493 
495  return s->constellation;
496 }
497 
499  return s->hierarchy;
500 }
501 
503  return s->code_rate_HP;
504 }
505 
507  return s->code_rate_LP;
508 }
509 
511  return s->guard_interval;
512 }
513 
515  return s->transmission_mode;
516 }
517 
519  return s->other_frequency_flag;
520 }
521 
524 }
525 
527  return s->service_type;
528 }
529 
531  int offset=0;
532  data.setPointerAndOffset<const descr_service>(s, offset);
533  providerName.setDataAndOffset(data+offset, s->provider_name_length, offset);
534  const descr_service_mid *mid;
535  data.setPointerAndOffset<const descr_service_mid>(mid, offset);
536  serviceName.setData(data+offset, mid->service_name_length);
537 }
538 
540  serviceLoop.setData(data+sizeof(descr_nvod_reference), getLength()-sizeof(descr_nvod_reference));
541 }
542 
544  return HILO(s->transport_stream_id);
545 }
546 
548  return HILO(s->original_network_id);
549 }
550 
552  return HILO(s->service_id);
553 }
554 
557 }
558 
560  return HILO(s->reference_service_id);
561 }
562 
565 }
566 
568  return s->stream_content;
569 }
570 
572  return s->stream_content_ext;
573 }
574 
576  return s->component_type;
577 }
578 
580  return s->component_tag;
581 }
582 
584  int offset=0;
585  data.setPointerAndOffset<const descr_component>(s, offset);
589  languageCode[3]=0;
590  description.setData(data+offset, getLength()-offset);
591 }
592 
595 }
596 
598  return (HILO(s->private_data_specifier_hi) << 16) | HILO(s->private_data_specifier_lo);
599 }
600 
602  subtitlingLoop.setData(data+sizeof(descr_subtitling), getLength()-sizeof(descr_subtitling));
603 }
604 
606  return s->subtitling_type;
607 }
608 
610  return HILO(s->composition_page_id);
611 }
612 
614  return HILO(s->ancillary_page_id);
615 }
616 
618  s=data.getData<const item_subtitling>();
622  languageCode[3]=0;
623 }
624 
626  return HILO(s->new_original_network_id);
627 }
628 
630  return HILO(s->new_transport_stream_id);
631 }
632 
634  return HILO(s->new_service_id);
635 }
636 
638  s=data.getData<const descr_service_move>();
639 }
640 
642  return s->coding_type;
643 }
644 
646  int offset=0;
648  frequencies.setData(data+offset, getLength()-offset);
649 }
650 
652  textualServiceIdentifier.setData(data+sizeof(descr_service_identifier), getLength()-sizeof(descr_service_identifier));
653 }
654 
656  identifierLoop.setData(data+sizeof(descr_content_identifier), getLength()-sizeof(descr_content_identifier));
657 }
658 
660  int offset=0;
662  if (s->crid_location == 0) {
663  identifier.setData(data+(offset-1), s->crid_length);
664  }
665  else {
666  identifier.setData(data+(offset-1), 2);
667  }
668 }
669 
671  return s->crid_type;
672 }
673 
675  return s->crid_location;
676 }
677 
679  DefaultAuthority.setData(data+sizeof(descr_default_authority), getLength()-sizeof(descr_default_authority));
680 }
681 
684 }
685 
687  int offset=0;
688  const entry_multilingual_name *s;
693  languageCode[3]=0;
694  name.setData(data+offset, s->text_length);
695 }
696 
698  return s->component_tag;
699 }
700 
702  int offset=0;
704  nameLoop.setData(data+sizeof(descr_multilingual_component), getLength()-sizeof(descr_multilingual_component));
705 }
706 
709 }
710 
712  int offset=0;
713  const entry_multilingual_name *s;
718  languageCode[3]=0;
719  providerName.setDataAndOffset(data+offset, s->text_length, offset);
722  name.setData(data+offset, mid->service_name_length);
723 }
724 
726  localTimeOffsetLoop.setData(data+sizeof(descr_local_time_offset), getLength()-sizeof(descr_local_time_offset));
727 }
728 
730  return s->country_region_id;
731 }
732 
734  return s->local_time_offset_polarity;
735 }
736 
738  return (s->local_time_offset_h << 8) | s->local_time_offset_m;
739 }
740 
742  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);
743 }
744 
746  return (s->next_time_offset_h << 8) | s->next_time_offset_m;
747 }
748 
751  countryCode[0]=s->country_code1;
752  countryCode[1]=s->country_code2;
753  countryCode[2]=s->country_code3;
754  countryCode[3]=0;
755 }
756 
758  int offset=0;
759  s1 = NULL;
760  data.setPointerAndOffset<const descr_linkage>(s, offset);
761  if (checkSize(getLength()-offset)) {
762  if (getLinkageType() == LinkageTypeMobileHandover)
763  data.setPointerAndOffset<const descr_linkage_8>(s1, offset);
764  privateData.assign(data.getData(offset), getLength()-offset);
765  }
766 }
767 
769  return HILO(s->transport_stream_id);
770 }
771 
773  return HILO(s->original_network_id);
774 }
775 
777  return HILO(s->service_id);
778 }
779 
781  return (LinkageType)s->linkage_type;
782 }
783 
785  return s1 == NULL ? 0 : s1->hand_over_type;
786 }
787 
789  return s1 == NULL ? 0 : s1->origin_type;
790 }
791 
793  return s1 == NULL ? 0 : HILO(s1->id);
794 }
795 
797  languageLoop.setData(data+sizeof(descr_iso_639_language), getLength()-sizeof(descr_iso_639_language));
798 
799  //all this is for backwards compatibility only
800  Loop::Iterator it;
801  Language first;
802  if (languageLoop.getNext(first, it)) {
803  languageCode[0]=first.languageCode[0];
804  languageCode[1]=first.languageCode[1];
805  languageCode[2]=first.languageCode[2];
806  languageCode[3]=0;
807  } else
808  languageCode[0]=0;
809 }
810 
816  languageCode[3]=0;
817 }
818 
820  return (AudioType)s->audio_type;
821 }
822 
824  int offset=0;
825  data.setPointerAndOffset<const descr_pdc>(s, offset);
826 }
827 
829  return ((s->pil0 & 0x0F) << 1) | ((s->pil1 & 0x80) >> 7);
830 }
831 
833  return (s->pil1 >> 3) & 0x0F;
834 }
835 
837  return ((s->pil1 & 0x07) << 2) | ((s->pil2 & 0xC0) >> 6);
838 }
839 
841  return s->pil2 & 0x3F;
842 }
843 
845  int offset=0;
847 }
848 
850  return s->ancillary_data_identifier;
851 }
852 
854  int offset=0;
855  input_stream_identifier=0;
857  if (s->scrambling_sequence_selector)
859  if (s->multiple_input_stream_flag)
860  input_stream_identifier = *data.getData(offset++);
861 }
862 
864  return s->scrambling_sequence_selector;
865 }
866 
868  return s->multiple_input_stream_flag;
869 }
870 
872  return s->backwards_compatibility_indicator;
873 }
874 
876  return sss == NULL ? 0 : (sss->scrambling_sequence_index_hi_lo << 16) | HILO(sss->scrambling_sequence_index_lo);
877 }
878 
880  int offset=0;
881  data.setPointerAndOffset<const descr_extension>(s, offset);
882  extended_data_flag = s->descriptor_length > 0x04;
883 }
884 
886  return extended_data_flag;
887 }
888 
890  return s->descriptor_tag_extension;
891 }
892 
894  int offset=0;
896  extended_data_flag = s->descriptor_length > 0x04;
897 }
898 
900  return extended_data_flag;
901 }
902 
904  return s->descriptor_tag_extension;
905 }
906 
908  return s->plp_id;
909 }
910 
912  return HILO(s->t2_system_id);
913 }
914 
916  return extended_data_flag ? s->siso_miso : -1;
917 }
918 
920  return extended_data_flag ? s->bandwidth : -1;
921 }
922 
924  return extended_data_flag ? s->guard_interval : -1;
925 }
926 
928  return extended_data_flag ? s->transmission_mode : -1;
929 }
930 
932  return extended_data_flag ? s->other_frequency_flag : -1;
933 }
934 
936  return extended_data_flag ? s->tfs_flag : -1;
937 }
938 
940  //this descriptor is only a header and a loop
941  logicalChannelLoop.setData(data+sizeof(descr_logical_channel), getLength()-sizeof(descr_logical_channel));
942 }
943 
945  return HILO(s->service_id);
946 }
947 
949  return s->visible_service_flag;
950 }
951 
953  return HILO(s->logical_channel_number);
954 }
955 
958 }
959 
961  //this descriptor is only a header and a loop
962  hdSimulcastLogicalChannelLoop.setData(data+sizeof(descr_hd_simulcast_logical_channel), getLength()-sizeof(descr_hd_simulcast_logical_channel));
963 }
964 
966  return HILO(s->service_id);
967 }
968 
970  return s->visible_service_flag;
971 }
972 
974  return HILO(s->logical_channel_number);
975 }
976 
979 }
980 
982  return HILO(s->original_network_id);
983 }
984 
986  return HILO(s->transport_stream_id);
987 }
988 
990  return HILO(s->service_id);
991 }
992 
996 }
997 
999  return HILO(s->mjd);
1000 }
1001 
1003  return s->start_time_loop;
1004 }
1005 
1007  return sizeof(item_premiere_content_transmission_day)+getLoopLength();
1008 }
1009 
1012  startTimeLoop.setData(data+sizeof(item_premiere_content_transmission_day), getLoopLength());
1013 }
1014 
1016  return DVBTime::getTime(mjd >> 8, mjd & 0xff, s->start_time_h, s->start_time_m, s->start_time_s);
1017 }
1018 
1021 }
1022 
1024  entryLoop.setData(data+sizeof(descr_application_signalling), getLength()-sizeof(descr_application_signalling));
1025 }
1026 
1028  return HILO(s->application_type);
1029 }
1030 
1032  return s->AIT_version_number;
1033 }
1034 
1037 }
1038 
1040  return s->service_bound_flag;
1041 }
1042 
1044  return s->visibility;
1045 }
1046 
1048  return s->application_priority;
1049 }
1050 
1052  int offset=0;
1053  const descr_application *dapp;
1054  data.setPointerAndOffset<const descr_application>(dapp, offset);
1055  profileLoop.setDataAndOffset(data+offset, dapp->application_profiles_length, offset);
1057  transportProtocolLabels.setData(data+offset, getLength()-offset);
1058 }
1059 
1061  return HILO(s->application_profile);
1062 }
1063 
1065  return s->version_major;
1066 }
1067 
1069  return s->version_minor;
1070 }
1071 
1073  return s->version_micro;
1074 }
1075 
1078 }
1079 
1081  nameLoop.setData(data+sizeof(descr_application_name), getLength()-sizeof(descr_application_name));
1082 }
1083 
1087  name.setData(data+sizeof(descr_application_name_entry), s->application_name_length);
1091  languageCode[3]=0;
1092 }
1093 
1095  return HILO(s->protocol_id);
1096 }
1097 
1099  return s->transport_protocol_label;
1100 }
1101 
1103  return remote;
1104 }
1105 
1107  return componentTag;
1108 }
1109 
1110 char *MHP_TransportProtocolDescriptor::getUrlBase(char *buffer, int size) {
1111  return UrlBase.getText(buffer, size);
1112 }
1113 
1115  int offset=0;
1116  remote=false;
1117  componentTag=-1;
1119  if (getProtocolId() == ObjectCarousel) {
1120  const transport_via_oc *oc;
1121  data.setPointerAndOffset<const transport_via_oc>(oc, offset);
1122  remote=oc->remote;
1123  if (remote) {
1124  const transport_via_oc_remote_end *rem;
1126  componentTag=rem->component_tag;
1127  } else {
1128  const transport_via_oc_end *rem;
1129  data.setPointerAndOffset<const transport_via_oc_end>(rem, offset);
1130  componentTag=rem->component_tag;
1131  }
1132  } else if (getProtocolId() == HTTPoverInteractionChannel) {
1133  const transport_via_http *http;
1134  data.setPointerAndOffset<const transport_via_http>(http, offset);
1135  UrlBase.setDataAndOffset(data+offset, http->url_base_length, offset);
1136 
1137  // fill URL Extension,
1138  UrlExtensionLoop.setData(data+offset, getLength()-offset);
1139  } else {
1140  //unimplemented
1141  }
1142 }
1143 
1147  UrlExtension.setData(data, s->url_extension_length);
1148 }
1149 
1151  applicationLoop.setData(data+sizeof(descr_dvbj_application), getLength()-sizeof(descr_dvbj_application));
1152 }
1153 
1156  parameter.setData(data+sizeof(descr_dvbj_application_entry), entry->parameter_length);
1157 }
1158 
1160  int offset=0;
1161  const descr_dvbj_application_location *first;
1163  baseDirectory.setDataAndOffset(data+offset, first->base_directory_length, offset);
1166  classPath.setDataAndOffset(data+offset, mid->classpath_extension_length, offset);
1167  initialClass.setData(data+offset, getLength()-offset);
1168 }
1169 
1171  return HILO(s->icon_flags);
1172 }
1173 
1175  int offset=0;
1178  iconLocator.setDataAndOffset(data+offset, first->icon_locator_length, offset);
1180 }
1181 
1183  return location.getText(buffer, size);
1184 }
1185 
1187  int offset=0;
1190  location.setDataAndOffset(data+offset, loc->descriptor_length, offset);
1191 }
1192 
1194  return HILOHILO(s->format_identifier);
1195 }
1196 
1198  int offset=0;
1199  data.setPointerAndOffset<const descr_registration>(s, offset);
1200  if (checkSize(getLength()-offset))
1201  privateData.assign(data.getData(offset), getLength()-offset);
1202 }
1203 
1205  return s->profile_idc;
1206 }
1207 
1209  return s->constraint_set0_flag;
1210 }
1211 
1213  return s->constraint_set1_flag;
1214 }
1215 
1217  return s->constraint_set2_flag;
1218 }
1219 
1221  return s->constraint_set3_flag;
1222 }
1223 
1225  return s->constraint_set4_flag;
1226 }
1227 
1229  return s->constraint_set5_flag;
1230 }
1231 
1233  return s->avc_compatible_flags;
1234 }
1235 
1237  return s->level_idc;
1238 }
1239 
1241  return s->avc_still_present;
1242 }
1243 
1245  return s->avc_24_hour_picture_flag;
1246 }
1247 
1249  return s->frame_packing_sei_not_present_flag;
1250 }
1251 
1253  int offset=0;
1254  data.setPointerAndOffset<const descr_avc>(s, offset);
1255  if (checkSize(getLength()-offset))
1256  privateData.assign(data.getData(offset), getLength()-offset);
1257 }
1258 
1259 } //end of namespace
int getProfileIdc() const
Definition: descriptor.c:1204
int getAVCCompatibleFlags() const
Definition: descriptor.c:1232
int getLevelIdc() const
Definition: descriptor.c:1236
int getConstraintSet3Flag() const
Definition: descriptor.c:1220
int getFramePackingSEINotPresentFlag() const
Definition: descriptor.c:1248
int getConstraintSet2Flag() const
Definition: descriptor.c:1216
int getConstraintSet1Flag() const
Definition: descriptor.c:1212
int getConstraintSet0Flag() const
Definition: descriptor.c:1208
int getConstraintSet4Flag() const
Definition: descriptor.c:1224
int getAVCStillPresent() const
Definition: descriptor.c:1240
int getConstraintSet5Flag() const
Definition: descriptor.c:1228
int getAVC24HourPictureFlag() const
Definition: descriptor.c:1244
virtual void Parse()
Definition: descriptor.c:1252
int getAncillaryDataIdentifier() const
Definition: descriptor.c:849
virtual void Parse()
Definition: descriptor.c:359
int getCaPid() const
Definition: descriptor.c:355
int getCaType() const
Definition: descriptor.c:351
void setPointerAndOffset(const T *&p, int &offset) const
Definition: util.h:56
const unsigned char * getData() const
Definition: util.h:51
int getComponentType() const
Definition: descriptor.c:575
int getStreamContentExt() const
Definition: descriptor.c:571
int getStreamContent() const
Definition: descriptor.c:567
virtual void Parse()
Definition: descriptor.c:583
int getComponentTag() const
Definition: descriptor.c:579
int getContentNibbleLevel1() const
Definition: descriptor.c:289
int getContentNibbleLevel2() const
Definition: descriptor.c:293
virtual void Parse()
Definition: descriptor.c:284
virtual int getLength()
Definition: si.c:96
const descr_extended_event * s
Definition: descriptor.h:48
StructureLoop< Item > itemLoop
Definition: descriptor.h:43
char * getTextItemized(const char *separation1="\t", const char *separation2="\n")
Definition: descriptor.c:197
char * getText(const char *separation1="\t", const char *separation2="\n")
Definition: descriptor.c:86
int getMaximumTextItemizedLength(const char *separation1="\t", const char *separation2="\n")
Definition: descriptor.c:184
int getMaximumTextLength(const char *separation1="\t", const char *separation2="\n")
Definition: descriptor.c:81
int getExtendedDataFlag() const
Definition: descriptor.c:885
virtual void Parse()
Definition: descriptor.c:879
int getExtensionDescriptorTag() const
Definition: descriptor.c:889
int getOriginalNetworkId() const
Definition: descriptor.c:772
int getTransportStreamId() const
Definition: descriptor.c:768
int getOriginType() const
Definition: descriptor.c:788
int getServiceId() const
Definition: descriptor.c:776
LinkageType getLinkageType() const
Definition: descriptor.c:780
virtual void Parse()
Definition: descriptor.c:757
int getHandOverType() const
Definition: descriptor.c:784
void reset()
Definition: si.h:325
char * getLocation(char *buffer, int size)
Definition: descriptor.c:1182
char * getUrlBase(char *buffer, int size)
Definition: descriptor.c:1110
virtual void Parse()
Definition: descriptor.c:374
bool checkSize(int offset)
Definition: si.c:37
CharArray data
Definition: si.h:240
virtual void Parse()
Definition: descriptor.c:823
int getDay() const
Definition: descriptor.c:828
int getMinute() const
Definition: descriptor.c:840
int getHour() const
Definition: descriptor.c:836
int getMonth() const
Definition: descriptor.c:832
int getFormatIdentifier() const
Definition: descriptor.c:1193
virtual void Parse()
Definition: descriptor.c:530
int getServiceType() const
Definition: descriptor.c:526
virtual void Parse()
Definition: descriptor.c:394
virtual void Parse()
Definition: descriptor.c:637
int getNewServiceId() const
Definition: descriptor.c:633
int getNewOriginalNetworkId() const
Definition: descriptor.c:625
int getNewTransportStreamId() const
Definition: descriptor.c:629
virtual void Parse()
Definition: descriptor.c:18
char * getText()
Definition: si.c:222
virtual void Parse()
Definition: descriptor.c:601
int getExtensionDescriptorTag() const
Definition: descriptor.c:903
virtual void Parse()
Definition: descriptor.c:326
void setDataAndOffset(CharArray d, int l, int &offset)
Definition: si.h:292
void setData(CharArray d, int l)
Definition: si.h:290
virtual int getLength()
Definition: si.h:293
time_t getTime(unsigned char date_hi, unsigned char date_lo, unsigned char timehr, unsigned char timemi, unsigned char timese)
Definition: util.c:190
Definition: descriptor.c:16
AudioType
Definition: si.h:216
size_t convertCharacterTable(const char *from, size_t fromLength, char *to, size_t toLength, const char *fromCode)
Definition: si.c:414
LinkageType
Definition: si.h:203
@ LinkageTypeMobileHandover
Definition: si.h:210
Definition: headers.h:1949
Definition: headers.h:1622
Definition: headers.h:1683
Definition: headers.h:1968
u_char application_profiles_length
Definition: headers.h:1928
Definition: headers.h:2044
u_char parameter_length
Definition: headers.h:2045
u_char service_name_length
Definition: headers.h:1035
u_char event_name_length
Definition: headers.h:1120
Definition: headers.h:1989
u_char item_description_length
Definition: headers.h:1153
Definition: headers.h:1300
#define HILOHILO(x)
Definition: util.h:22
#define HILO(x)
Definition: util.h:21