dist/trunk/tstools/epgdump/sdt.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4
   5 #include "sdt.h"
   6 #include "ts_ctl.h"
   7
   8 int parseSDThead(unsigned char *data, SDThead *h) {
   9         int boff = 0;
  10
  11         memset(h, 0, sizeof(SDThead));
  12
  13         boff = 0;
  14         h->table_id = getBit(data, &boff, 8);
  15         h->section_syntax_indicator = getBit(data, &boff, 1);
  16         h->reserved_future_use1 = getBit(data, &boff, 1);
  17         h->reserved1 = getBit(data, &boff, 2);
  18         h->section_length = getBit(data, &boff, 12);
  19         h->transport_stream_id = getBit(data, &boff, 16);
  20         h->reserved2 = getBit(data, &boff, 2);
  21         h->version_number = getBit(data, &boff, 5);
  22         h->current_next_indicator = getBit(data, &boff, 1);
  23         h->section_number = getBit(data, &boff, 8);
  24         h->last_section_number = getBit(data, &boff, 8);
  25         h->original_network_id = getBit(data, &boff, 16);
  26         h->reserved_future_use2 = getBit(data, &boff, 8);
  27
  28         return 11;
  29 }
  30
  31 int parseSDTbody(unsigned char *data, SDTbody *b) {
  32         int boff = 0;
  33
  34         memset(b, 0, sizeof(SDTbody));
  35
  36         b->service_id = getBit(data, &boff, 16);
  37         b->reserved_future_use1 = getBit(data, &boff, 3);
  38         b->EIT_user_defined_flags = getBit(data, &boff, 3);
  39         b->EIT_schedule_flag = getBit(data, &boff, 1);
  40         b->EIT_present_following_flag = getBit(data, &boff, 1);
  41         b->running_status = getBit(data, &boff, 3);
  42         b->free_CA_mode = getBit(data, &boff, 1);
  43         b->descriptors_loop_length = getBit(data, &boff, 12);
  44
  45         return 5;
  46 }
  47
  48 int parseSVCdesc(unsigned char *data, SVCdesc *desc) {//0x48\82Ì\83T\81[\83r\83X\8bL\8fq\8eq\81A\95ú\91\97\8bÇ\82Ì\96¼\91O\82È\82Ç\82ª\93ü\82Á\82Ä\82¢\82é\82æ\82¤
  49         int boff = 0;
  50
  51         memset(desc, 0, sizeof(SVCdesc));
  52
  53         desc->descriptor_tag = getBit(data, &boff, 8);
  54         desc->descriptor_length = getBit(data, &boff, 8);
  55         desc->service_type = getBit(data, &boff, 8);
  56         desc->service_provider_name_length = getBit(data, &boff, 8);
  57         getStr(desc->service_provider_name, data, &boff, desc->service_provider_name_length);
  58         desc->service_name_length = getBit(data, &boff, 8);
  59         getStr(desc->service_name, data, &boff, desc->service_name_length);
  60
  61         return desc->descriptor_length + 2;
  62 }
  63 int             serachid(SVT_CONTROL *top, int service_id)
  64 {
  65         SVT_CONTROL     *cur = top ;
  66         while(cur != NULL){
  67                 if(cur->event_id == service_id){
  68                         return 1 ;
  69                 }
  70                 cur = cur->next ;
  71         }
  72         return 0 ;
  73 }
  74
  75 void    enqueue_sdt(SVT_CONTROL *top, SVT_CONTROL *sdtptr)
  76 {
  77         SVT_CONTROL     *cur ;
  78         if(top->next == NULL){
  79                 top->next = sdtptr ;
  80                 top->prev = top ;
  81                 return ;
  82         }
  83         cur = top->next ;
  84         while(cur != NULL){
  85                 if(sdtptr->event_id < cur->event_id){
  86                         if(cur->prev != NULL){
  87                                 cur->prev->next = sdtptr ;
  88                                 sdtptr->prev = cur->prev ;
  89                         }
  90                         cur->prev = sdtptr ;
  91                         sdtptr->next = cur ;
  92                         return ;
  93                 }
  94                 if(cur->next == NULL){
  95                         cur->next = sdtptr ;
  96                         sdtptr->prev = cur ;
  97                         return ;
  98                 }
  99                 cur = cur->next ;
 100         }
 101         return ;
 102
 103 }
 104
 105 void dumpSDT(unsigned char *ptr, SVT_CONTROL *top)
 106 {
 107
 108         SDThead  sdth;
 109         SDTbody  sdtb;
 110         SVCdesc  desc;
 111         SVT_CONTROL     *svtptr ;
 112         int             rc ;
 113
 114         int len = 0;
 115         int loop_len = 0;
 116
 117         /* SDT */
 118         len = parseSDThead(ptr, &sdth);
 119         ptr += len;
 120         loop_len = sdth.section_length - (len - 3 + 4); // 3¤Ï¶¦ÄÌ¥Ø¥Ã¥ÀÄ¹ 4¤ÏCRC
 121         while(loop_len > 0) {
 122                 len = parseSDTbody(ptr, &sdtb);
 123                 ptr += len;
 124                 loop_len -= len;
 125                 parseSVCdesc(ptr, &desc);
 126
 127                 rc = serachid(top, sdtb.service_id);
 128                 if(rc == 0){
 129                         svtptr = calloc(1, sizeof(SVT_CONTROL));
 130                         svtptr->event_id = sdtb.service_id;
 131                         svtptr->original_network_id = sdth.original_network_id;
 132                         svtptr->transport_stream_id = sdth.transport_stream_id;
 133                         svtptr->event_id = sdtb.service_id;
 134                         memcpy(svtptr->servicename, desc.service_name, strlen(desc.service_name));
 135                         enqueue_sdt(top, svtptr);
 136 #if 0
 137                         printf("STATION=%s,%d,%d,%d,%d\n",
 138                                 desc.service_name,sdtb.service_id,sdth.transport_stream_id,
 139                                 sdth.original_network_id,sdtb.service_id);
 140 #endif
 141 #if 0
 142                         printf("SDT=%s,%d,%x,%x,%x,%x,%x,%x,%x\n",
 143                                 desc.service_name, sdtb.service_id, sdtb.reserved_future_use1,
 144                                 sdtb.EIT_user_defined_flags, sdtb.EIT_schedule_flag, sdtb.EIT_present_following_flag,
 145                                 sdtb.running_status, sdtb.free_CA_mode, sdtb.descriptors_loop_length);
 146 /*
 147 0x01:\83f\83W\83^\83\8bTV\83T\81[\83r\83X
 148 0xA5:\83v\83\8d\83\82\81[\83V\83\87\83\93\89f\91\9c\83T\81[\83r\83X
 149 0x0C:\83f\81[\83^\83T\81[\83r\83X
 150  */
 151                         printf("SDT=(%x:%x)%s,%d,%d,%d,%d,%d(%d,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x)\n",
 152                                         sdth.table_id, desc.service_type,
 153                                         desc.service_name, sdtb.service_id,
 154                                         desc.descriptor_tag, desc.descriptor_length, desc.service_type,
 155                                         desc.service_provider_name_length, desc.service_name_length,
 156                                         sdth.table_id, sdth.section_syntax_indicator, sdth.reserved_future_use1,
 157                                         sdth.reserved1, sdth.section_length, sdth.transport_stream_id,
 158                                         sdth.reserved2, sdth.version_number, sdth.current_next_indicator,
 159                                         sdth.section_number, sdth.last_section_number, sdth.original_network_id,
 160                                         sdth.reserved_future_use2);
 161 #endif
 162                 }
 163
 164                 ptr += sdtb.descriptors_loop_length;
 165                 loop_len -= sdtb.descriptors_loop_length;
 166         }
 167
 168         return;
 169 }
 170 void dumpSDT_chout(unsigned char *ptr, SVT_CONTROL *top,STATION **station, int * station_count,char *ontvheader)
 171 {
 172
 173         SDThead  sdth;
 174         SDTbody  sdtb;
 175         SVCdesc  desc;
 176         SVT_CONTROL     *svtptr ;
 177         STATION * pStation = *station;
 178         int             rc ;
 179
 180         int len = 0;
 181         int loop_len = 0;
 182         char sid[80];
 183         int stationi=*station_count;
 184         /* SDT */
 185         len = parseSDThead(ptr, &sdth);
 186         ptr += len;
 187         loop_len = sdth.section_length - (len - 3 + 4); // 3¤Ï¶¦ÄÌ¥Ø¥Ã¥ÀÄ¹ 4¤ÏCRC
 188         while(loop_len > 0) {
 189                 len = parseSDTbody(ptr, &sdtb);
 190                 ptr += len;
 191                 loop_len -= len;
 192                 parseSVCdesc(ptr, &desc);
 193                 rc = serachid(top, sdtb.service_id);
 194                 if(rc == 0){
 195                         svtptr = calloc(1, sizeof(SVT_CONTROL));
 196                         svtptr->event_id = sdtb.service_id;
 197                         svtptr->original_network_id = sdth.original_network_id;
 198                         svtptr->transport_stream_id = sdth.transport_stream_id;
 199                         svtptr->event_id = sdtb.service_id;
 200                         memcpy(svtptr->servicename, desc.service_name, strlen(desc.service_name));
 201                         if (desc.service_type == 1){
 202                                 enqueue_sdt(top, svtptr);
 203                                 pStation = realloc(pStation,(stationi+1)*sizeof(STATION));
 204                                 if (!pStation) printf( "Realloc returned NULL!!! stationi = %d\n", stationi);
 205                                 //char sidt[32];
 206                                 //char *tt="_";
 207                                 //sprintf(sidt, "%d", sdtb.service_id ); //ontv\83t\83H\81[\83}\83b\83g\82æ\82\82í\82©\82ç\82È\82¢
 208                                 //STATION stt={NULL,NULL,sdth.transport_stream_id,
 209                                 //      sdth.original_network_id,sdtb.service_id};
 210                                 //\88È\89º\82É\93W\8aJ\82µ\82½
 211                                 //strcpy(sid,ontvheader);
 212                                 //strcat(sid,tt);
 213                                 //strcat(sid,sidt);
 214                                 sprintf(sid, "%s_%d", ontvheader, sdtb.service_id );
 215                                 pStation[stationi].name = malloc( strlen(desc.service_name) + 1 );
 216                                 pStation[stationi].ontv = malloc( strlen(sid) + 1 );
 217                                 pStation[stationi].tsId = sdth.transport_stream_id;
 218                                 pStation[stationi].onId = sdth.original_network_id;
 219                                 pStation[stationi].svId = sdtb.service_id;
 220
 221                                 strcpy(pStation[stationi].name, desc.service_name);
 222                                 strcpy(pStation[stationi].ontv, sid);
 223
 224                                 //printf("%s\n",sttt.name);
 225                                 //printf("%s\n",pStation[stationi].name);
 226                                 //printf( "iii %d \n", stationi);
 227                                 stationi++;
 228
 229                         //sprintf(*lastservicename, "%s", "lastservice2" );
 230 #if 0
 231                         printf("STATION=%s,%d,%d,%d,%d,%d\n",
 232                                 desc.service_name,sdtb.service_id,sdth.transport_stream_id,
 233                                 sdth.original_network_id,sdtb.service_id,desc.service_type);
 234 #endif
 235
 236                         }
 237
 238 #if 0
 239                         printf("STATION=%s,%s,%d,%d,%d\n",
 240                                 sttt.name,sttt.ontv,sttt.tsId,sttt.onId,sttt.svId
 241                                 );
 242 #endif
 243 #if 0
 244                         printf("SDT=%s,%d,%x,%x,%x,%x,%x,%x,%x\n",
 245                                 desc.service_name, sdtb.service_id, sdtb.reserved_future_use1,
 246                                 sdtb.EIT_user_defined_flags, sdtb.EIT_schedule_flag, sdtb.EIT_present_following_flag,
 247                                 sdtb.running_status, sdtb.free_CA_mode, sdtb.descriptors_loop_length);
 248 /*
 249 0x01:\83f\83W\83^\83\8bTV\83T\81[\83r\83X
 250 0xA5:\83v\83\8d\83\82\81[\83V\83\87\83\93\89f\91\9c\83T\81[\83r\83X
 251 0x0C:\83f\81[\83^\83T\81[\83r\83X
 252  */
 253
 254                         printf("SDT=(%x:%x)%s,%d,%d,%d,%d,%d(%d,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x)\n",
 255                                         sdth.table_id, desc.service_type,
 256                                         desc.service_name, sdtb.service_id,
 257                                         desc.descriptor_tag, desc.descriptor_length, desc.service_type,
 258                                         desc.service_provider_name_length, desc.service_name_length,
 259                                         sdth.table_id, sdth.section_syntax_indicator, sdth.reserved_future_use1,
 260                                         sdth.reserved1, sdth.section_length, sdth.transport_stream_id,
 261                                         sdth.reserved2, sdth.version_number, sdth.current_next_indicator,
 262                                         sdth.section_number, sdth.last_section_number, sdth.original_network_id,
 263                                         sdth.reserved_future_use2);
 264 #endif
 265                 }
 266                 //ptr += sdtb.descriptors_loop_length;
 267                 loop_len -= sdtb.descriptors_loop_length;
 268
 269                 if (loop_len>0){
 270                         ptr += sdtb.descriptors_loop_length;
 271                 }
 272
 273         }
 274         *station = pStation;
 275         *station_count = stationi;
 276         //printf("stationi %d -",stationi);//stationi==294\82Å\97\8e\82¿\82é
 277         return;
 278 }