vdr 2.6.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
33 return s->descriptor_number;
34}
35
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
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
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;
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
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;
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;
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
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;
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
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
1156 parameter.setData(data+sizeof(descr_dvbj_application_entry), entry->parameter_length);
1157}
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
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:326
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:241
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:293
void setData(CharArray d, int l)
Definition: si.h:291
virtual int getLength()
Definition: si.h:294
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:217
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:204
@ LinkageTypeMobileHandover
Definition: si.h:211
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