tstools/epgdump/ts.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4
   5 #include "ts.h"
   6
   7 static unsigned int CalcCrc(unsigned int crc, unsigned char *buf, int len);
   8 static int checkcrc(SECcache *secs);
   9
  10 SECcache *readTS(FILE *in, SECcache secs[], int size) {
  11         static int rcount = 0;
  12         static int ridx = -1;
  13
  14         TSpacket pk;
  15
  16         unsigned char buf[1024];
  17
  18         int boff;
  19         int len;
  20         unsigned char *payptr;
  21
  22         int inchar;
  23         int i;
  24
  25         /* sync¥Ð¥¤¥È¤Þ¤ÇÆÉ¤ßÈô¤Ð¤· */
  26         if(rcount == 0) {
  27                 while((inchar = fgetc(in)) != EOF) {
  28                         if((inchar & 0xFF) == 0x47) {
  29                                 //fseek(in, -1, SEEK_CUR);
  30                                 ungetc(inchar, in);
  31                                 break;
  32                         }
  33                 }
  34                 if(inchar == EOF) {
  35                         return NULL;
  36                 }
  37         }
  38
  39 retry:
  40
  41         /* Ìá¤¹¤Ù¤»Ä¤ê¤¬¤¢¤ë¤«? */
  42         if(ridx >= 0 && secs[ridx].cont) {
  43                 /* ¥Ð¥Ã¥Õ¥¡¥Á¥§¥Ã¥¯ */
  44                 if((secs[ridx].cur.payload[secs[ridx].curlen] & 0xFF) == 0xFF) {
  45                         secs[ridx].cont = 0;
  46                         secs[ridx].seclen = 0;
  47                         secs[ridx].setlen = 0;
  48                         secs[ridx].curlen = 0;
  49                 } else {
  50                         len = secs[ridx].cur.payloadlen - secs[ridx].curlen;
  51                         /* Á´ÉôÀßÄêºÑ¤ß¥Á¥§¥Ã¥¯ */
  52                         if(len == 0) {
  53                                 secs[ridx].cont = 0;
  54                                 secs[ridx].seclen = 0;
  55                                 secs[ridx].setlen = 0;
  56                                 secs[ridx].curlen = 0;
  57                         } else {
  58                                 /* ¤³¤³¤Çseclen¤¬¸Ù¤ë¤è¤¦¤ËTSÊ¬³ä¤µ¤ì¤Æ¤¤¤ë¤Èº¤¤ë¤Ê @@
  59                                    if(secs[ridx].pid == 0x12) {
  60                                    int check = secs[ridx].cur.payload[secs[ridx].curlen] & 0xFF;
  61                                    if(!(check == 0x4E ||
  62                                    check == 0x4F ||
  63                                    (check >= 0x50 && check <= 0x6F))) {
  64                                    secs[ridx].curlen -= 3;
  65                                    }
  66                                    }
  67                                 */
  68
  69                                 boff = 12;
  70                                 secs[ridx].seclen = getBit(&secs[ridx].cur.payload[secs[ridx].curlen], &boff, 12) + 3; // ¥Ø¥Ã¥À
  71
  72                                 /*
  73                                   if(secs[ridx].seclen == 2334) {
  74                                   printf("aa");
  75                                   }
  76                                 */
  77
  78                                 /* TS¥Ç¡¼¥¿Ä¹-ÀßÄêºÑ¤ß¥Ç¡¼¥¿Ä¹ */
  79                                 if(secs[ridx].seclen > len) {
  80                                         memcpy(secs[ridx].buf, &secs[ridx].cur.payload[secs[ridx].curlen], len);
  81                                         secs[ridx].setlen = len;
  82                                         secs[ridx].curlen = 0;
  83                                         secs[ridx].cont   = 1;
  84                                         /* ¼¡¤Î¥ì¥³¡¼¥ÉÆÉ¤ß¹þ¤ß */
  85                                 } else {
  86                                         memcpy(secs[ridx].buf,
  87                                                    &secs[ridx].cur.payload[secs[ridx].curlen], secs[ridx].seclen);
  88                                         secs[ridx].setlen  = secs[ridx].seclen;
  89                                         secs[ridx].curlen += secs[ridx].seclen;
  90                                         secs[ridx].cont = 1;
  91
  92                                         /* CRC¤Î¥Á¥§¥Ã¥¯ */
  93                                         if(checkcrc(&(secs[ridx]))) {
  94                                                 return &(secs[ridx]); /* Ìá¤ë */
  95                                         }
  96                                         goto retry; /* ¤â¤¦°ì²ó */
  97                                 }
  98                         }
  99                 }
 100         }
 101
 102         int roffset = 0;
 103         while(1) {
 104                 if(fread(buf+roffset, 188-roffset, 1, in) != 1) {
 105                         /* »Ä¤ê¤Î½èÍý? */
 106                         return NULL;
 107                 }
 108                 roffset = 0;
 109                 rcount++;
 110
 111                 if((buf[0] & 0xFF) != 0x47) {
 112                         /* ºÇ½é¤ÏbufÃæ¤Ë0x47¤¬¤¢¤ë¤«¥Á¥§¥Ã¥¯ */
 113                         for(i = 1; i < 188; i++) {
 114                                 if((buf[i] & 0xFF) == 0x47) {
 115                                         break;
 116                                 }
 117                         }
 118
 119                         if(i < 188) {
 120                                 /* ¤½¤³¤«¤éºÆÆÉ¤ß¹þ¤ß¤·¤ÆÍß¤·¤¤¤Î¤Çseek */
 121                                 //fseek(in, (188 - i) * -1, SEEK_CUR);
 122                                 roffset = i;
 123                                 memmove(buf, buf + i, 188 - i);
 124                                 continue;
 125                         }
 126
 127                         while((inchar = fgetc(in)) != EOF) {
 128                                 if((inchar & 0xFF) == 0x47) {
 129                                         //fseek(in, -1, SEEK_CUR);
 130                                         ungetc(inchar, in);
 131                                         break;
 132                                 }
 133                         }
 134                         if(inchar == EOF) {
 135                                 return NULL;
 136                         }
 137                         continue;
 138                 }
 139
 140                 /*
 141                   if(rcount == 406502) {
 142                   printf("aa");
 143                   }
 144                 */
 145
 146
 147                 pk.rcount = rcount;
 148
 149                 boff = 0;
 150                 pk.sync = getBit(buf, &boff, 8);
 151                 pk.transport_error_indicator = getBit(buf, &boff, 1);
 152                 pk.payload_unit_start_indicator = getBit(buf, &boff, 1);
 153                 pk.transport_priority = getBit(buf, &boff, 1);
 154                 pk.pid = getBit(buf, &boff, 13);
 155                 pk.transport_scrambling_control = getBit(buf, &boff, 2);
 156                 pk.adaptation_field_control = getBit(buf, &boff, 2);
 157                 pk.continuity_counter = getBit(buf, &boff, 4);
 158
 159                 /*
 160                   adaptation_field_control 2 bslbf
 161                   continuity_counter 4 uimsbf
 162                   if(adaptation_field_control = = '10' || adaptation_field_control = = '11'){
 163                   adaptation_field()
 164                   }
 165                   ...
 166                   adaptation_field() {
 167                   adaptation_field_length 8 uimsbf
 168                   if (adaptation_field_length > 0) {
 169                   discontinuity_indicator....
 170
 171                   00 Reserved for future use by ISO/IEC
 172                   01 No adaptation_field, payload only
 173                   10 Adaptation_field only, no payload
 174                   11 Adaptation_field followed by payload
 175
 176                 */
 177
 178                 pk.payloadlen = 184;
 179
 180                 if(pk.adaptation_field_control == 2) {
 181                         continue;
 182                 }
 183
 184                 if(pk.adaptation_field_control == 3) {
 185                         len = getBit(buf, &boff, 8);
 186                         payptr = buf + (boff / 8) + len;
 187                         pk.payloadlen -= (len + 1);
 188                 } else {
 189                         payptr = buf + (boff / 8);
 190                 }
 191                 if(pk.payloadlen < 0){
 192                         continue ;
 193                 }
 194
 195                 /*
 196                    if the Transport Stream packet carries the first byte of a PSI section, the payload_unit_start_indicator value
 197                    shall be '1', indicating that the first byte of the payload of this Transport Stream packet carries the pointer_field.
 198                 */
 199                 if(pk.payload_unit_start_indicator == 1) {
 200                         /* pointer_field¤Ï¤¤¤é¤Ê¤¤ */
 201                         payptr += 1;
 202                         pk.payloadlen -= 1;
 203                 }
 204                 memset(pk.payload, 0xFF, sizeof(pk.payload));
 205 #if 1   /* 07/07/2009 add: */
 206                 if( pk.payloadlen > sizeof(pk.payload) ){
 207                         continue;
 208                 }
 209 #endif
 210                 memcpy(pk.payload, payptr, pk.payloadlen);
 211
 212                 /*
 213                   if(pk.rcount == 62) {
 214                   printf("62\n");
 215                   }
 216
 217                   if(pk.rcount == 63) {
 218                   printf("63\n");
 219                   }
 220                 */
 221
 222                 /* ¶½Ì£¤Î¤¢¤ëpid¤«³ÎÇ§ */
 223                 for(int i = 0;i < size; i++) {
 224                         if(secs[i].pid == pk.pid) {
 225                                 secs[i].cur = pk;
 226                                 /* ÅÓÃæ½èÍýÃæ¤«ºÇ½é¤«? */
 227                                 if(!secs[i].cont) {
 228                                         /* ºÇ½é ¥»¥¯¥·¥ç¥óÄ¹¤òÄ´¤Ù¤ë */
 229                                         boff = 12;
 230                                         secs[i].seclen = getBit(secs[i].cur.payload, &boff, 12) + 3; // ¥Ø¥Ã¥À;
 231                                         /*
 232                                           if(secs[i].seclen == 2334) {
 233                                           printf("aa");
 234                                           }
 235                                         */
 236
 237                                         if(secs[i].seclen > secs[i].cur.payloadlen) {
 238                                                 memcpy(secs[i].buf, secs[i].cur.payload, secs[i].cur.payloadlen);
 239                                                 secs[i].setlen = secs[i].cur.payloadlen;
 240                                                 secs[i].cont = 1;
 241                                                 continue;
 242                                         }
 243                                         memcpy(secs[i].buf, secs[i].cur.payload, secs[i].seclen);
 244                                         secs[i].setlen = secs[i].seclen;
 245                                         secs[i].curlen = secs[i].seclen;
 246                                         secs[i].cont = 1;
 247                                         ridx = i;
 248                                         /* CRC¤Î¥Á¥§¥Ã¥¯ */
 249                                         if(checkcrc(&(secs[ridx]))) {
 250                                                 return &(secs[i]); /* ¼è¤ê¹ç¤¨¤ºÌá¤ë */
 251                                         }
 252                                         goto retry; /* »Ä¤ê½èÍý¤Ø */
 253                                 }
 254                                 /* ¥»¥¯¥·¥ç¥óÄ¹-ÀßÄêºÑ¤ßÄ¹ */
 255                                 len = secs[i].seclen - secs[i].setlen;
 256                                 if(len > secs[i].cur.payloadlen) {
 257                                         /* Á´ÂÎÅ¾Á÷ */
 258                                         memcpy(&secs[i].buf[secs[i].setlen],
 259                                                    secs[i].cur.payload, secs[i].cur.payloadlen);
 260                                         secs[i].setlen += secs[i].cur.payloadlen;
 261                                         continue;
 262                                 }
 263                                 /* ¥»¥¯¥·¥ç¥óÄ¹¤Î»Ä¤ê¤òÀßÄê */
 264                                 memcpy(&secs[i].buf[secs[i].setlen], secs[i].cur.payload, len);
 265                                 secs[i].setlen  = secs[i].seclen;
 266                                 secs[i].curlen += len;
 267                                 secs[i].cont    = 1;
 268                                 ridx = i;
 269                                 /* CRC¤Î¥Á¥§¥Ã¥¯ */
 270                                 if(checkcrc(&(secs[ridx]))) {
 271                                         return &(secs[i]);
 272                                 }
 273                                 goto retry; /* »Ä¤ê½èÍý¤Ø */
 274                         }
 275                 }
 276         }
 277
 278         //return NULL;
 279 }
 280
 281 /* BonTest/TsStream.cpp¤«¤é¤Î¥Ñ¥¯¥ê */
 282 unsigned int CalcCrc(unsigned int crc, unsigned char *buf, int len) {
 283         unsigned int c = crc;
 284         int n;
 285
 286         static const unsigned int CrcTable[256] = {
 287                 0x00000000UL, 0x04C11DB7UL, 0x09823B6EUL, 0x0D4326D9UL, 0x130476DCUL, 0x17C56B6BUL, 0x1A864DB2UL, 0x1E475005UL, 0x2608EDB8UL, 0x22C9F00FUL, 0x2F8AD6D6UL, 0x2B4BCB61UL, 0x350C9B64UL, 0x31CD86D3UL, 0x3C8EA00AUL, 0x384FBDBDUL,
 288                 0x4C11DB70UL, 0x48D0C6C7UL, 0x4593E01EUL, 0x4152FDA9UL, 0x5F15ADACUL, 0x5BD4B01BUL, 0x569796C2UL, 0x52568B75UL, 0x6A1936C8UL, 0x6ED82B7FUL, 0x639B0DA6UL, 0x675A1011UL, 0x791D4014UL, 0x7DDC5DA3UL, 0x709F7B7AUL, 0x745E66CDUL,
 289                 0x9823B6E0UL, 0x9CE2AB57UL, 0x91A18D8EUL, 0x95609039UL, 0x8B27C03CUL, 0x8FE6DD8BUL, 0x82A5FB52UL, 0x8664E6E5UL, 0xBE2B5B58UL, 0xBAEA46EFUL, 0xB7A96036UL, 0xB3687D81UL, 0xAD2F2D84UL, 0xA9EE3033UL, 0xA4AD16EAUL, 0xA06C0B5DUL,
 290                 0xD4326D90UL, 0xD0F37027UL, 0xDDB056FEUL, 0xD9714B49UL, 0xC7361B4CUL, 0xC3F706FBUL, 0xCEB42022UL, 0xCA753D95UL, 0xF23A8028UL, 0xF6FB9D9FUL, 0xFBB8BB46UL, 0xFF79A6F1UL, 0xE13EF6F4UL, 0xE5FFEB43UL, 0xE8BCCD9AUL, 0xEC7DD02DUL,
 291                 0x34867077UL, 0x30476DC0UL, 0x3D044B19UL, 0x39C556AEUL, 0x278206ABUL, 0x23431B1CUL, 0x2E003DC5UL, 0x2AC12072UL, 0x128E9DCFUL, 0x164F8078UL, 0x1B0CA6A1UL, 0x1FCDBB16UL, 0x018AEB13UL, 0x054BF6A4UL, 0x0808D07DUL, 0x0CC9CDCAUL,
 292                 0x7897AB07UL, 0x7C56B6B0UL, 0x71159069UL, 0x75D48DDEUL, 0x6B93DDDBUL, 0x6F52C06CUL, 0x6211E6B5UL, 0x66D0FB02UL, 0x5E9F46BFUL, 0x5A5E5B08UL, 0x571D7DD1UL, 0x53DC6066UL, 0x4D9B3063UL, 0x495A2DD4UL, 0x44190B0DUL, 0x40D816BAUL,
 293                 0xACA5C697UL, 0xA864DB20UL, 0xA527FDF9UL, 0xA1E6E04EUL, 0xBFA1B04BUL, 0xBB60ADFCUL, 0xB6238B25UL, 0xB2E29692UL, 0x8AAD2B2FUL, 0x8E6C3698UL, 0x832F1041UL, 0x87EE0DF6UL, 0x99A95DF3UL, 0x9D684044UL, 0x902B669DUL, 0x94EA7B2AUL,
 294                 0xE0B41DE7UL, 0xE4750050UL, 0xE9362689UL, 0xEDF73B3EUL, 0xF3B06B3BUL, 0xF771768CUL, 0xFA325055UL, 0xFEF34DE2UL, 0xC6BCF05FUL, 0xC27DEDE8UL, 0xCF3ECB31UL, 0xCBFFD686UL, 0xD5B88683UL, 0xD1799B34UL, 0xDC3ABDEDUL, 0xD8FBA05AUL,
 295                 0x690CE0EEUL, 0x6DCDFD59UL, 0x608EDB80UL, 0x644FC637UL, 0x7A089632UL, 0x7EC98B85UL, 0x738AAD5CUL, 0x774BB0EBUL, 0x4F040D56UL, 0x4BC510E1UL, 0x46863638UL, 0x42472B8FUL, 0x5C007B8AUL, 0x58C1663DUL, 0x558240E4UL, 0x51435D53UL,
 296                 0x251D3B9EUL, 0x21DC2629UL, 0x2C9F00F0UL, 0x285E1D47UL, 0x36194D42UL, 0x32D850F5UL, 0x3F9B762CUL, 0x3B5A6B9BUL, 0x0315D626UL, 0x07D4CB91UL, 0x0A97ED48UL, 0x0E56F0FFUL, 0x1011A0FAUL, 0x14D0BD4DUL, 0x19939B94UL, 0x1D528623UL,
 297                 0xF12F560EUL, 0xF5EE4BB9UL, 0xF8AD6D60UL, 0xFC6C70D7UL, 0xE22B20D2UL, 0xE6EA3D65UL, 0xEBA91BBCUL, 0xEF68060BUL, 0xD727BBB6UL, 0xD3E6A601UL, 0xDEA580D8UL, 0xDA649D6FUL, 0xC423CD6AUL, 0xC0E2D0DDUL, 0xCDA1F604UL, 0xC960EBB3UL,
 298                 0xBD3E8D7EUL, 0xB9FF90C9UL, 0xB4BCB610UL, 0xB07DABA7UL, 0xAE3AFBA2UL, 0xAAFBE615UL, 0xA7B8C0CCUL, 0xA379DD7BUL, 0x9B3660C6UL, 0x9FF77D71UL, 0x92B45BA8UL, 0x9675461FUL, 0x8832161AUL, 0x8CF30BADUL, 0x81B02D74UL, 0x857130C3UL,
 299                 0x5D8A9099UL, 0x594B8D2EUL, 0x5408ABF7UL, 0x50C9B640UL, 0x4E8EE645UL, 0x4A4FFBF2UL, 0x470CDD2BUL, 0x43CDC09CUL, 0x7B827D21UL, 0x7F436096UL, 0x7200464FUL, 0x76C15BF8UL, 0x68860BFDUL, 0x6C47164AUL, 0x61043093UL, 0x65C52D24UL,
 300                 0x119B4BE9UL, 0x155A565EUL, 0x18197087UL, 0x1CD86D30UL, 0x029F3D35UL, 0x065E2082UL, 0x0B1D065BUL, 0x0FDC1BECUL, 0x3793A651UL, 0x3352BBE6UL, 0x3E119D3FUL, 0x3AD08088UL, 0x2497D08DUL, 0x2056CD3AUL, 0x2D15EBE3UL, 0x29D4F654UL,
 301                 0xC5A92679UL, 0xC1683BCEUL, 0xCC2B1D17UL, 0xC8EA00A0UL, 0xD6AD50A5UL, 0xD26C4D12UL, 0xDF2F6BCBUL, 0xDBEE767CUL, 0xE3A1CBC1UL, 0xE760D676UL, 0xEA23F0AFUL, 0xEEE2ED18UL, 0xF0A5BD1DUL, 0xF464A0AAUL, 0xF9278673UL, 0xFDE69BC4UL,
 302                 0x89B8FD09UL, 0x8D79E0BEUL, 0x803AC667UL, 0x84FBDBD0UL, 0x9ABC8BD5UL, 0x9E7D9662UL, 0x933EB0BBUL, 0x97FFAD0CUL, 0xAFB010B1UL, 0xAB710D06UL, 0xA6322BDFUL, 0xA2F33668UL, 0xBCB4666DUL, 0xB8757BDAUL, 0xB5365D03UL, 0xB1F740B4UL
 303         };
 304
 305         for (n = 0; n < len; n++) {
 306                 c = (c << 8) ^ CrcTable[((((c >> 24) & 0xFF) ^ buf[n]) & 0XFF)];
 307         }
 308
 309         return c;
 310 }
 311
 312
 313 int checkcrc(SECcache *secs) {
 314
 315 #if 1   /* 07/07/2009 add: °Û¾ï¾õÂÖ²óÈò¤Î¤¿¤á */
 316         /* ¥»¥¯¥·¥ç¥óºÇÂçÄ¹¤òÄ¶¤¨¤ë¤³¤È¤Ê¤É¤¢¤êÆÀ¤Ê¤¤¤Ï¤º¤À¤¬... */
 317         if( secs->seclen > MAXSECLEN ){
 318                 /* ¤è¤¯Ê¬¤«¤é¤ó¤Î¤ÇÇË´þ¤·¤Æ¤ä¤ë */
 319                 return 0;
 320         }
 321 #endif
 322
 323         /* ¥»¥¯¥·¥ç¥ó¤Î½ª¤ê¤ËÃÖ¤«¤ì¤ë4¥Ð¥¤¥È¤ÎCRC32¤Ï¡¢
 324            CRC·×»»¤Î·ë²Ì0¤Ë¤Ê¤ë¤è¤¦¤ËÀßÄê¤µ¤ì¤ë¡£
 325            ÃÍ¤¬È¯À¸¤·¤¿¾ì¹ç¤Ï¡¢¥¨¥é¡¼¤Ê¤Î¤ÇÂÐ¾Ý³°¤Ë¤¹¤ë */
 326         if(CalcCrc(0xffffffffU, secs->buf, secs->seclen)) {
 327 //              fprintf(stderr, "tblid:0x%x CRC error\n", secs->buf[0]);
 328                 return 0;
 329         }
 330         return 1;
 331 }
 332