vdr 2.7.5
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
16namespace 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;
28 data.setPointerAndOffset<const descr_short_event_mid>(mid, offset);
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;
42 data.setPointerAndOffset<const descr_extended_event>(s, offset);
43 languageCode[0]=s->lang_code1;
44 languageCode[1]=s->lang_code2;
45 languageCode[2]=s->lang_code3;
46 languageCode[3]=0;
47 itemLoop.setDataAndOffset(data+offset, s->length_of_items, offset);
48 const descr_extended_event_mid *mid;
49 data.setPointerAndOffset<const descr_extended_event_mid>(mid, offset);
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);
57 itemDescription.setDataAndOffset(data+offset, first->item_description_length, offset);
58 const item_extended_event_mid *mid;
59 data.setPointerAndOffset<const item_extended_event_mid>(mid, offset);
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
81int 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
86char *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
92char *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
169char *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
184int 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
197char *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
203char *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.
241bool 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
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
312}
313
315 return s->rating;
316}
317
319 s=data.getData<const parental_rating>();
320 languageCode[0]=s->lang_code1;
321 languageCode[1]=s->lang_code2;
322 languageCode[2]=s->lang_code3;
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>();
333 languageCode[0]=s->lang_code1;
334 languageCode[1]=s->lang_code2;
335 languageCode[2]=s->lang_code3;
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
373
377
381
383 return (HILO(s->carousel_id_hi) << 16) | HILO(s->carousel_id_lo);
384}
385
387 return s->FormatId;
388}
389
393
397
399 return HILO(s->service_id);
400}
401
403 return s->service_type;
404}
405
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
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
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
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
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
558
560 return HILO(s->reference_service_id);
561}
562
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);
586 languageCode[0]=s->lang_code1;
587 languageCode[1]=s->lang_code2;
588 languageCode[2]=s->lang_code3;
589 languageCode[3]=0;
590 description.setData(data+offset, getLength()-offset);
591}
592
596
598 return (HILO(s->private_data_specifier_hi) << 16) | HILO(s->private_data_specifier_lo);
599}
600
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>();
619 languageCode[0]=s->lang_code1;
620 languageCode[1]=s->lang_code2;
621 languageCode[2]=s->lang_code3;
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;
647 data.setPointerAndOffset<const descr_frequency_list>(s, offset);
648 frequencies.setData(data+offset, getLength()-offset);
649}
650
654
658
660 int offset=0;
661 data.setPointerAndOffset<const content_identifier_entry>(s, offset);
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
681
685
687 int offset=0;
689 data.setPointerAndOffset<const entry_multilingual_name>(s, offset);
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;
703 data.setPointerAndOffset<const descr_multilingual_component>(s, offset);
705}
706
710
712 int offset=0;
714 data.setPointerAndOffset<const entry_multilingual_name>(s, offset);
718 languageCode[3]=0;
719 providerName.setDataAndOffset(data+offset, s->text_length, offset);
721 data.setPointerAndOffset<const entry_multilingual_service_name_mid>(mid, offset);
722 name.setData(data+offset, mid->service_name_length);
723}
724
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
750 s=data.getData<const local_time_offset_entry>();
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)) {
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
798
799 //all this is for backwards compatibility only
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
812 s=data.getData<const descr_iso_639_language_loop>();
813 languageCode[0]=s->lang_code1;
814 languageCode[1]=s->lang_code2;
815 languageCode[2]=s->lang_code3;
816 languageCode[3]=0;
817}
818
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;
846 data.setPointerAndOffset<const descr_ancillary_data>(s, offset);
847}
848
850 return s->ancillary_data_identifier;
851}
852
854 int offset=0;
856 data.setPointerAndOffset<const descr_s2_satellite_delivery_system>(s, offset);
857 if (s->scrambling_sequence_selector)
858 data.setPointerAndOffset<const descr_scrambling_sequence_selector>(sss, offset);
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
888
890 return s->descriptor_tag_extension;
891}
892
894 int offset=0;
895 data.setPointerAndOffset<const descr_t2_delivery_system>(s, offset);
896 extended_data_flag = s->descriptor_length > 0x04;
897}
898
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
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
959
964
968
972
976
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
997
1001
1003 return s->start_time_loop;
1004}
1005
1009
1014
1016 return DVBTime::getTime(mjd >> 8, mjd & 0xff, s->start_time_h, s->start_time_m, s->start_time_s);
1017}
1018
1022
1026
1030
1034
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);
1056 data.setPointerAndOffset<const descr_application_end>(s, 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
1079
1083
1086 s=data.getData<const descr_application_name_entry>();
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
1109
1110char *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;
1118 data.setPointerAndOffset<const descr_transport_protocol>(s, offset);
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;
1125 data.setPointerAndOffset<const transport_via_oc_remote_end>(rem, offset);
1127 } else {
1128 const transport_via_oc_end *rem;
1129 data.setPointerAndOffset<const transport_via_oc_end>(rem, offset);
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
1146 s=data.getData<const descr_url_extension_entry>();
1147 UrlExtension.setData(data, s->url_extension_length);
1148}
1149
1153
1158
1160 int offset=0;
1162 data.setPointerAndOffset<const descr_dvbj_application_location>(first, offset);
1163 baseDirectory.setDataAndOffset(data+offset, first->base_directory_length, offset);
1165 data.setPointerAndOffset<const descr_dvbj_application_location_mid>(mid, 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;
1177 data.setPointerAndOffset<const descr_application_icons_descriptor>(first, offset);
1178 iconLocator.setDataAndOffset(data+offset, first->icon_locator_length, offset);
1179 data.setPointerAndOffset<const descr_application_icons_descriptor_end>(s, offset);
1180}
1181
1183 return location.getText(buffer, size);
1184}
1185
1187 int offset=0;
1189 data.setPointerAndOffset<const descr_simple_application_location_descriptor>(loc, offset);
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
const descr_avc * s
Definition descriptor.h:793
int getProfileIdc() const
int getAVCCompatibleFlags() const
int getLevelIdc() const
int getConstraintSet3Flag() const
int getFramePackingSEINotPresentFlag() const
int getConstraintSet2Flag() const
int getConstraintSet1Flag() const
int getConstraintSet0Flag() const
CharArray privateData
Definition descriptor.h:789
virtual void Parse() override
int getConstraintSet4Flag() const
int getAVCStillPresent() const
int getConstraintSet5Flag() const
int getAVC24HourPictureFlag() const
const descr_ancillary_data * s
Definition descriptor.h:513
virtual void Parse() override
Definition descriptor.c:844
int getAncillaryDataIdentifier() const
Definition descriptor.c:849
StructureLoop< ApplicationEntryDescriptor > entryLoop
Definition descriptor.h:651
virtual void Parse() override
CharArray privateData
Definition descriptor.h:147
virtual void Parse() override
Definition descriptor.c:359
const descr_ca * s
Definition descriptor.h:151
int getCaPid() const
Definition descriptor.c:355
int getCaType() const
Definition descriptor.c:351
virtual void Parse() override
Definition descriptor.c:378
TypeLoop< SixteenBit > identifiers
Definition descriptor.h:172
const descr_cable_delivery_system * s
Definition descriptor.h:234
virtual void Parse() override
Definition descriptor.c:470
virtual void Parse() override
Definition descriptor.c:390
const descr_carousel_identifier * s
Definition descriptor.h:184
const descr_component * s
Definition descriptor.h:306
int getComponentType() const
Definition descriptor.c:575
virtual void Parse() override
Definition descriptor.c:583
int getStreamContentExt() const
Definition descriptor.c:571
int getStreamContent() const
Definition descriptor.c:567
int getComponentTag() const
Definition descriptor.c:579
const nibble_content * s
Definition descriptor.h:100
virtual void Parse() override
Definition descriptor.c:305
virtual void Parse() override
Definition descriptor.c:284
StructureLoop< Nibble > nibbleLoop
Definition descriptor.h:102
const content_identifier_entry * s
Definition descriptor.h:376
StructureLoop< Identifier > identifierLoop
Definition descriptor.h:378
virtual void Parse() override
Definition descriptor.c:655
virtual void Parse() override
Definition descriptor.c:678
GroupDescriptor ** array
Definition si.h:492
virtual int getLength() override
Definition si.c:96
virtual void Parse() override
Definition descriptor.c:53
const descr_extended_event * s
Definition descriptor.h:48
virtual void Parse() override
Definition descriptor.c:40
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
const descr_extension * s
Definition descriptor.h:538
int getExtensionDescriptorTag() const
Definition descriptor.c:889
virtual void Parse() override
Definition descriptor.c:879
TypeLoop< ThirtyTwoBit > frequencies
Definition descriptor.h:351
const descr_frequency_list * s
Definition descriptor.h:355
virtual void Parse() override
Definition descriptor.c:645
StructureLoop< HdSimulcastLogicalChannel > hdSimulcastLogicalChannelLoop
Definition descriptor.h:592
const descr_iso_639_language_loop * s
Definition descriptor.h:488
StructureLoop< Language > languageLoop
Definition descriptor.h:490
virtual void Parse() override
Definition descriptor.c:796
int getOriginalNetworkId() const
Definition descriptor.c:772
const descr_linkage * s
Definition descriptor.h:473
int getTransportStreamId() const
Definition descriptor.c:768
const descr_linkage_8 * s1
Definition descriptor.h:474
int getOriginType() const
Definition descriptor.c:788
int getServiceId() const
Definition descriptor.c:776
LinkageType getLinkageType() const
Definition descriptor.c:780
virtual void Parse() override
Definition descriptor.c:757
int getHandOverType() const
Definition descriptor.c:784
const local_time_offset_entry * s
Definition descriptor.h:453
StructureLoop< LocalTimeOffset > localTimeOffsetLoop
Definition descriptor.h:455
virtual void Parse() override
Definition descriptor.c:725
StructureLoop< LogicalChannel > logicalChannelLoop
Definition descriptor.h:574
virtual void Parse() override
Definition descriptor.c:939
void reset()
Definition si.h:325
const application_profile_entry * s
Definition descriptor.h:666
StructureLoop< Profile > profileLoop
Definition descriptor.h:670
TypeLoop< EightBit > transportProtocolLabels
Definition descriptor.h:674
const descr_application_end * s
Definition descriptor.h:676
virtual void Parse() override
const descr_application_icons_descriptor_end * s
Definition descriptor.h:753
virtual void Parse() override
StructureLoop< NameEntry > nameLoop
Definition descriptor.h:691
virtual void Parse() override
StructureLoop< ApplicationEntry > applicationLoop
Definition descriptor.h:732
virtual void Parse() override
char * getLocation(char *buffer, int size)
char * getUrlBase(char *buffer, int size)
StructureLoop< UrlExtensionEntry > UrlExtensionLoop
Definition descriptor.h:712
virtual void Parse() override
const descr_transport_protocol * s
Definition descriptor.h:717
virtual void Parse() override
Definition descriptor.c:701
const descr_multilingual_component * s
Definition descriptor.h:421
virtual void Parse() override
Definition descriptor.c:686
StructureLoop< Name > nameLoop
Definition descriptor.h:401
virtual void Parse() override
Definition descriptor.c:682
virtual void Parse() override
Definition descriptor.c:707
virtual void Parse() override
Definition descriptor.c:555
const item_nvod_reference * s
Definition descriptor.h:279
virtual void Parse() override
Definition descriptor.c:539
StructureLoop< Service > serviceLoop
Definition descriptor.h:281
virtual void Parse() override
Definition descriptor.c:374
bool checkSize(int offset)
Definition si.c:37
CharArray data
Definition si.h:240
int getDay() const
Definition descriptor.c:828
virtual void Parse() override
Definition descriptor.c:823
int getMinute() const
Definition descriptor.c:840
int getHour() const
Definition descriptor.c:836
const descr_pdc * s
Definition descriptor.h:504
int getMonth() const
Definition descriptor.c:832
virtual void Parse() override
Definition descriptor.c:318
StructureLoop< Rating > ratingLoop
Definition descriptor.h:119
virtual void Parse() override
Definition descriptor.c:309
const item_premiere_content_transmission_day * s
Definition descriptor.h:621
StructureLoop< StartDayEntry > startDayLoop
Definition descriptor.h:623
const descr_premiere_content_transmission * s
Definition descriptor.h:630
const descr_private_data_specifier * s
Definition descriptor.h:315
virtual void Parse() override
Definition descriptor.c:593
virtual void Parse() override
const descr_registration * s
Definition descriptor.h:772
const descr_scrambling_sequence_selector * sss
Definition descriptor.h:527
const descr_s2_satellite_delivery_system * s
Definition descriptor.h:526
const descr_satellite_delivery_system * s
Definition descriptor.h:221
virtual void Parse() override
Definition descriptor.c:446
const descr_service * s
Definition descriptor.h:265
virtual void Parse() override
Definition descriptor.c:530
int getServiceType() const
Definition descriptor.c:526
virtual void Parse() override
Definition descriptor.c:651
virtual void Parse() override
Definition descriptor.c:406
const descr_service_list_loop * s
Definition descriptor.h:200
virtual void Parse() override
Definition descriptor.c:394
StructureLoop< Service > serviceLoop
Definition descriptor.h:202
virtual void Parse() override
Definition descriptor.c:637
int getNewOriginalNetworkId() const
Definition descriptor.c:625
const descr_service_move * s
Definition descriptor.h:345
int getNewTransportStreamId() const
Definition descriptor.c:629
virtual void Parse() override
Definition descriptor.c:18
const descr_stream_identifier * s
Definition descriptor.h:160
virtual void Parse() override
Definition descriptor.c:370
char * getText()
Definition si.c:222
virtual void Parse() override
Definition descriptor.c:617
StructureLoop< Subtitling > subtitlingLoop
Definition descriptor.h:332
virtual void Parse() override
Definition descriptor.c:601
virtual void Parse() override
Definition descriptor.c:893
const descr_t2_delivery_system * s
Definition descriptor.h:557
const item_teletext * s
Definition descriptor.h:136
virtual void Parse() override
Definition descriptor.c:331
virtual void Parse() override
Definition descriptor.c:326
StructureLoop< Teletext > teletextLoop
Definition descriptor.h:138
const descr_terrestrial_delivery * s
Definition descriptor.h:254
const descr_time_shifted_event * s
Definition descriptor.h:85
virtual void Parse() override
Definition descriptor.c:280
const descr_time_shifted_service * s
Definition descriptor.h:292
virtual void Parse() override
Definition descriptor.c:563
virtual int getLength() override
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
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
Definition headers.h:1989
Definition headers.h:1300
#define HILOHILO(x)
Definition util.h:22
#define HILO(x)
Definition util.h:21