vdr 2.7.3
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;
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
35
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
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
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
325
327 //this descriptor is only a header and a loop
328 teletextLoop.setData(data+sizeof(descr_teletext), getLength()-sizeof(descr_teletext));
329}
330
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
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
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
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
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
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;
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
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
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
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
685
687 int offset=0;
693 languageCode[3]=0;
694 name.setData(data+offset, s->text_length);
695}
696
698 return s->component_tag;
699}
700
706
710
712 int offset=0;
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
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
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;
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;
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
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
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);
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
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
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;
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
1158
1160 int offset=0;
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;
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
int getAVCCompatibleFlags() const
int getLevelIdc() const
int getConstraintSet3Flag() const
int getFramePackingSEINotPresentFlag() const
int getConstraintSet2Flag() const
int getConstraintSet1Flag() const
int getConstraintSet0Flag() const
int getConstraintSet4Flag() const
int getAVCStillPresent() const
int getConstraintSet5Flag() const
int getAVC24HourPictureFlag() const
virtual void Parse()
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
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)
char * getUrlBase(char *buffer, int size)
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
virtual void Parse()
Definition descriptor.c:530
int getServiceType() const
Definition descriptor.c:526
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: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
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