src/mpeg2/ts/Table.cpp

   1 /*\r
   2  *  Table.cpp\r
   3  */\r
   4 \r
   5 #include "b25/aribstr.h"\r
   6 #include "mpeg2/ts/Header.h"\r
   7 #include "mpeg2/ts/Table.h"\r
   8 \r
   9 namespace MPEG2\r
  10 {\r
  11 namespace TS\r
  12 {\r
  13 \r
  14 Table::Table()\r
  15 {\r
  16     _pid = 0xFFFF;\r
  17     _length = 0;\r
  18 }\r
  19 \r
  20 Table::~Table()\r
  21 {\r
  22 }\r
  23 \r
  24 //\r
  25 // CRC\r
  26 //\r
  27 int Table::GetCrc32(\r
  28         unsigned char* data,                            // [in]         CRC data\r
  29         int len)                                                        // [in]         CRC data length\r
  30 {\r
  31         int crc;\r
  32         int i, j;\r
  33 \r
  34         crc = 0xFFFFFFFF;\r
  35         for (i = 0; i < len; i++)\r
  36         {\r
  37                 char x;\r
  38                 x = data[i];\r
  39 \r
  40                 for (j = 0; j < 8; j++)\r
  41                 {\r
  42                         int c;\r
  43                         int bit;\r
  44 \r
  45                         bit = (x >> (7 - j)) & 0x1;\r
  46 \r
  47                         c = 0;\r
  48                         if (crc & 0x80000000)\r
  49                         {\r
  50                                 c = 1;\r
  51                         }\r
  52 \r
  53                         crc = crc << 1;\r
  54 \r
  55                         if (c ^ bit)\r
  56                         {\r
  57                                 crc ^= 0x04C11DB7;\r
  58                         }\r
  59 \r
  60                         crc &= 0xFFFFFFFF;\r
  61                 }\r
  62         }\r
  63 \r
  64         return crc;\r
  65 }\r
  66 /*\r
  67 bool Table::decode(uint8_t *packet)\r
  68 {\r
  69     bool result = false;\r
  70 \r
  71     Header header(packet);\r
  72 \r
  73     if (header._transport_error)\r
  74     {\r
  75         printf("transport error.\n");\r
  76         return false;\r
  77     }\r
  78 \r
  79     if (header._payload_unit_start)\r
  80     {\r
  81         _pid = header._pid;\r
  82         _length = 0;\r
  83         memset(_section, 0x00, sizeof(_section));\r
  84     }\r
  85 \r
  86 #if 0\r
  87     if ((_pid == header._pid) && (_continuity_counter == header._continuity_counter))\r
  88     {\r
  89         // adaptation_field_control\r
  90         if (header._adaptation_field_control != 0x02)\r
  91         {\r
  92             uint16_t length;\r
  93             length = header._payload_unit_start ? ((((packet[0x06] << 8) + packet[0x07]) & 0x0FFF) + 3) : ((((_section[0x01] << 8) + _section[0x02]) & 0x0FFF) + 3);\r
  94             uint8_t offset = 0x04;\r
  95             if (header._adaptation_field_control == 0x03)\r
  96             {\r
  97                 offset = offset + 1 + packet[0x04];\r
  98             }\r
  99             if (_length == 0)\r
 100             {\r
 101                 // pointer_field\r
 102                 offset += 1;\r
 103             }\r
 104             uint16_t cpylen = ((length - _length) < (PACKET_SIZE - offset)) ? (length - _length) : (PACKET_SIZE - offset);\r
 105 \r
 106             memcpy(&_section[_length], &packet[offset], cpylen);\r
 107             _length += cpylen;\r
 108             _continuty_counter++;\r
 109 \r
 110             if (_length == length)\r
 111             {\r
 112                 if (GetCrc32(_section, _length) == 0)\r
 113                 {\r
 114                     // decode\r
 115                     result = decode_section();\r
 116                 }\r
 117             }\r
 118         }\r
 119     }\r
 120 #endif\r
 121 \r
 122     return result;\r
 123 }\r
 124 */\r
 125 bool Table::decode(Header *header, uint8_t *packet)\r
 126 {\r
 127     bool result = false;\r
 128 \r
 129     if (header->_adaptation_field_control != 0x02)\r
 130     {\r
 131         uint16_t length;\r
 132         length = header->_payload_unit_start ? ((((packet[0x06] << 8) + packet[0x07]) & 0x0FFF) + 3) : ((((_section[0x01] << 8) + _section[0x02]) & 0x0FFF) + 3);\r
 133         uint8_t offset = 0x04;\r
 134         if (header->_adaptation_field_control == 0x03)\r
 135         {\r
 136             offset = offset + packet[0x04];\r
 137         }\r
 138 \r
 139         if (header->_payload_unit_start)\r
 140         {\r
 141             if (_length != 0)\r
 142             {\r
 143                 if (packet[offset] != 0)\r
 144                 {\r
 145                     memcpy(&_section[_length], &packet[offset + 1], packet[offset]);\r
 146                 }\r
 147                 result = decode_section();\r
 148                 _length = 0;\r
 149             }\r
 150 \r
 151             offset += (1 + packet[offset]);\r
 152         }\r
 153 \r
 154         memcpy(&_section[_length], &packet[offset], PACKET_SIZE - offset);\r
 155         _length += (PACKET_SIZE - offset);\r
 156     }\r
 157 \r
 158     return result;\r
 159 }\r
 160 \r
 161 bool Table::decode_section()\r
 162 {\r
 163     return false;\r
 164 }\r
 165 \r
 166 void Table::reset()\r
 167 {\r
 168     printf("Table::reset\n");\r
 169     _pid = 0xFFFF;\r
 170     _length = 0;\r
 171     memset(_section, 0x00, sizeof(_section));\r
 172 }\r
 173 \r
 174 static int getBit(unsigned char *byte, int *pbit, int gbit)\r
 175 {\r
 176         int pbyte = *pbit / 8;\r
 177         unsigned char *fbyte = byte + pbyte;\r
 178 \r
 179         int cutbit = *pbit - (pbyte * 8);\r
 180         int lcutbit = 32 - (cutbit + gbit);\r
 181 \r
 182         unsigned char tbuf[4]; //\r
 183         unsigned int tnum;\r
 184 \r
 185         memcpy(tbuf, fbyte, sizeof(unsigned char) * 4);\r
 186 \r
 187         //\r
 188         tbuf[0] = tbuf[0] << cutbit;\r
 189         tbuf[0] = tbuf[0] >> cutbit;\r
 190 \r
 191         //\r
 192         tnum = tbuf[0] << 24 | tbuf[1] << 16 | tbuf[2] << 8 | tbuf[3];\r
 193 \r
 194         //\r
 195         tnum = tnum >> lcutbit;\r
 196 \r
 197         *pbit += gbit;\r
 198 \r
 199         return tnum;\r
 200 }\r
 201 \r
 202 #define MAXSECLEN 4096\r
 203 \r
 204 static void getStr(char *tostr, unsigned char *byte, int *pbit, int len)\r
 205 {\r
 206     char str[MAXSECLEN];\r
 207     int pbyte = *pbit / 8;\r
 208     unsigned char *fbyte = byte + pbyte;\r
 209 \r
 210     memset(str, 0, sizeof(char) * MAXSECLEN);\r
 211     memcpy(str, fbyte, len);\r
 212 \r
 213     *pbit += (len * 8);\r
 214 \r
 215     AribToString(tostr, str, len);\r
 216 }\r
 217 \r
 218 static void getStr(char *tostr, unsigned char *byte, int len)\r
 219 {\r
 220     char str[MAXSECLEN];\r
 221 \r
 222     memset(str, 0, sizeof(char) * MAXSECLEN);\r
 223     memcpy(str, byte, len);\r
 224 \r
 225     AribToString(tostr, str, len);\r
 226 }\r
 227 \r
 228 static uint16_t parseContentDescriptor(uint8_t *buf, ContentDescriptor *content)\r
 229 {\r
 230 //    printf("%s\n", __FUNCTION__);\r
 231     for (int i = 0; i < (content->descriptor_length / 2); ++i)\r
 232     {\r
 233         content->contents[i].content_nibble_level_1 = (buf[i * 2 + 0x02] & 0xF0) >> 4;\r
 234         content->contents[i].content_nibble_level_2 = buf[i * 2 + 0x02] & 0x0F;\r
 235         content->contents[i].user_nibble_1 = (buf[i * 2 + 0x03] & 0xF0) >> 4;\r
 236         content->contents[i].user_nibble_2 = buf[i * 2 + 0x03] & 0x0F;\r
 237     }\r
 238     return content->descriptor_length + 2;\r
 239 }\r
 240 \r
 241 static uint16_t parseShortEventDescriptor(uint8_t *buf, ShortEventDescriptor *short_event)\r
 242 {\r
 243 //    printf("%s\n", __FUNCTION__);\r
 244     uint16_t result = short_event->descriptor_length + 2;\r
 245 #if 0\r
 246     memcpy(&short_event->ISO_639_language_code[0], &buf[0x02], 3);\r
 247     short_event->event_name_length = buf[0x05];\r
 248     if ((short_event->event_name_length + 5) <= short_event->descriptor_length)\r
 249     {\r
 250 //        memcpy(&short_event->event_name[0], &buf[0x06], short_event->event_name_length);\r
 251         getStr((char *)short_event->event_name, &buf[0x06], short_event->event_name_length);\r
 252         short_event->text_length = buf[short_event->event_name_length + 6];\r
 253         if ((short_event->text_length + short_event->event_name_length + 5) == short_event->descriptor_length)\r
 254         {\r
 255 //            memcpy(&short_event->text[0], &buf[short_event->event_name_length + 6], short_event->text_length);\r
 256             getStr((char *)short_event->text, &buf[short_event->event_name_length + 6], short_event->text_length);\r
 257 //            printf("%s() success.\n", __FUNCTION__);\r
 258         }\r
 259         else\r
 260         {\r
 261             printf("%s() event_name_length = %d\n", __FUNCTION__, short_event->event_name_length);\r
 262             printf("%s() text_length error. %d\n", __FUNCTION__, short_event->text_length);\r
 263             result = 0;\r
 264         }\r
 265     }\r
 266     else\r
 267     {\r
 268         printf("%s() descriptor_length = %d\n", __FUNCTION__, short_event->descriptor_length);\r
 269         printf("%s() event_name_length error. %d\n", __FUNCTION__, short_event->event_name_length);\r
 270         result = 0;\r
 271     }\r
 272 #else\r
 273     int boff = 0;\r
 274 \r
 275     memset(short_event, 0, sizeof(ShortEventDescriptor));\r
 276 \r
 277     short_event->descriptor_tag = getBit(buf, &boff, 8);\r
 278     if ((short_event->descriptor_tag & 0xFF) == 0x4D)\r
 279     {\r
 280         short_event->descriptor_length = getBit(buf, &boff, 8);\r
 281         memcpy(short_event->ISO_639_language_code, buf + boff / 8, 3);\r
 282         /* desc->ISO_639_language_code = getBit(data, &boff, 24); */\r
 283         boff += 24;\r
 284 \r
 285         short_event->event_name_length = getBit(buf, &boff, 8);\r
 286 //        memset((char *)short_event->event_name, 0x00, MAX_DESC_LEN);\r
 287 //        getStr((char *)short_event->event_name, buf, &boff, short_event->event_name_length);\r
 288         memcpy((char *)short_event->event_name, buf + boff / 8, short_event->event_name_length);\r
 289         boff += short_event->event_name_length * 8;\r
 290 \r
 291         short_event->text_length = getBit(buf, &boff, 8);\r
 292 //        memset((char *)short_event->text, 0x00, MAX_DESC_LEN);\r
 293 //        getStr((char *)short_event->text, buf, &boff, short_event->text_length);\r
 294         memcpy((char *)short_event->text, buf + boff / 8, short_event->text_length);\r
 295     }\r
 296     else\r
 297     {\r
 298         result = false;\r
 299     }\r
 300 #endif\r
 301     return result;\r
 302 }\r
 303 \r
 304 static uint16_t parseExtendedEventDescriptor(uint8_t *buf, ExtendedEventDescriptor *extended)\r
 305 {\r
 306 //    printf("%s\n", __FUNCTION__);\r
 307     uint16_t result = extended->descriptor_length + 2;\r
 308 #if 1\r
 309     extended->descriptor_number = (buf[0x02] & 0xF0) >> 4;\r
 310     extended->last_descriptor_number = buf[0x02] & 0x0F;\r
 311     memcpy(&extended->ISO_639_language_code[0], &buf[0x03], 3);\r
 312     extended->length_of_items = buf[0x06];\r
 313     extended->item_count = 0;\r
 314     if ((extended->length_of_items + 6) <= extended->descriptor_length)\r
 315     {\r
 316         extended->text_length = 0;\r
 317         extended->text_length = buf[extended->length_of_items + 7];\r
 318         if ((extended->text_length + extended->length_of_items + 6) == extended->descriptor_length)\r
 319         {\r
 320             memcpy(&extended->text[0], &buf[extended->length_of_items + 7], extended->text_length);\r
 321 //            memset((char *)extended->text, 0x00, MAX_DESC_LEN);\r
 322 //            getStr((char *)extended->text, &buf[extended->length_of_items + 7], extended->text_length);\r
 323 \r
 324             int item_remain = extended->length_of_items;\r
 325             int item_offset = 0x07;\r
 326             while (item_remain >= 2)\r
 327             {\r
 328                 extended->items[extended->item_count].item_description_length = buf[item_offset++];\r
 329                 if (extended->items[extended->item_count].item_description_length > 0)\r
 330                 {\r
 331                     memcpy(&extended->items[extended->item_count].item_description[0], &buf[item_offset],\r
 332                            extended->items[extended->item_count].item_description_length);\r
 333 //                    memset((char *)&extended->items[extended->item_count].item_description[0], 0x00, MAX_DESC_LEN);\r
 334 //                    getStr((char *)&extended->items[extended->item_count].item_description[0], &buf[item_offset],\r
 335 //                           extended->items[extended->item_count].item_description_length);\r
 336                     item_offset += extended->items[extended->item_count].item_description_length;\r
 337                 }\r
 338                 item_remain -= (1 + extended->items[extended->item_count].item_description_length);\r
 339                 if (item_remain < 1)\r
 340                 {\r
 341                     printf("%s item desc len error.\n", __FUNCTION__);\r
 342                     result = 0;\r
 343                     break;\r
 344                 }\r
 345                 \r
 346                 extended->items[extended->item_count].item_length = buf[item_offset++];\r
 347                 if (extended->items[extended->item_count].item_length > 0)\r
 348                 {\r
 349                     memcpy(&extended->items[extended->item_count].item[0], &buf[item_offset],\r
 350                            extended->items[extended->item_count].item_length);\r
 351 //                    memset((char *)&extended->items[extended->item_count].item[0], 0x00, MAX_DESC_LEN);\r
 352 //                    getStr((char *)&extended->items[extended->item_count].item[0], &buf[item_offset],\r
 353 //                           extended->items[extended->item_count].item_length);\r
 354                     item_offset += extended->items[extended->item_count].item_length;\r
 355                 }\r
 356                 item_remain -= (1 + extended->items[extended->item_count].item_length);\r
 357                 if ((item_remain < 0) || (item_remain == 1))\r
 358                 {\r
 359                     printf("%s item len error. %d\n", __FUNCTION__, item_remain);\r
 360                     result = 0;\r
 361                     break;\r
 362                 }\r
 363                 else {\r
 364 //                    printf("eevt success.\n");\r
 365                 }\r
 366 \r
 367                 ++extended->item_count;\r
 368             }\r
 369         }\r
 370         else\r
 371         {\r
 372             printf("%s() length_of_items = %d\n", __FUNCTION__, extended->length_of_items);\r
 373             printf("%s() text_length error. %d\n", __FUNCTION__, extended->text_length);\r
 374             result = 0;\r
 375         }\r
 376     }\r
 377     else\r
 378     {\r
 379         printf("%s() descriptor_length = %d\n", __FUNCTION__, extended->descriptor_length);\r
 380         printf("%s() length_of_items error. %d\n", __FUNCTION__, extended->length_of_items);\r
 381         result = 0;\r
 382     }\r
 383 #else\r
 384 #endif\r
 385     return result;\r
 386 }\r
 387 \r
 388 uint16_t Table::parseDescriptor(uint8_t *buf, uint16_t length, Descriptor *descriptor)\r
 389 {\r
 390     uint16_t result = 0;\r
 391 \r
 392     descriptor->other.descriptor_tag    = buf[0x00];\r
 393     descriptor->other.descriptor_length = buf[0x01];\r
 394 \r
 395     // length check\r
 396     if ((descriptor->other.descriptor_length + 2) <= length)\r
 397     {\r
 398         switch (descriptor->other.descriptor_tag)\r
 399         {\r
 400         case 0x4D: // Short event descriptor\r
 401             result = parseShortEventDescriptor(buf, &descriptor->short_event);\r
 402             break;\r
 403 \r
 404         case 0x4E: // Extended event descriptor\r
 405             result = parseExtendedEventDescriptor(buf, &descriptor->extended_event);\r
 406             break;\r
 407 \r
 408         case 0x54: // Content descriptor\r
 409             result = parseContentDescriptor(buf, &descriptor->content);\r
 410             break;\r
 411 \r
 412         case 0x50: // Component\r
 413 //            result = parseComponentDescriptor(hoge);\r
 414             result = descriptor->other.descriptor_length + 2;\r
 415             break;\r
 416 \r
 417         case 0xC4: // Audio Component \r
 418 //            result = parseAudioComponentDescriptor(hoge);\r
 419             result = descriptor->other.descriptor_length + 2;\r
 420             break;\r
 421 \r
 422 \r
 423         case 0xD5: // Series descriptor\r
 424 //            result = parseSeriesDescriptor(hoge);\r
 425             result = descriptor->other.descriptor_length + 2;\r
 426             break;\r
 427 \r
 428         default:\r
 429             memcpy(&descriptor->other.descriptor[0], &buf[0x02], descriptor->other.descriptor_length);\r
 430             result = descriptor->other.descriptor_length + 2;\r
 431             break;\r
 432         }\r
 433     }\r
 434     else\r
 435     {\r
 436         printf("%s() length = %d\n", __FUNCTION__, length);\r
 437         printf("%s() descriptor_tag = %d\n", __FUNCTION__, descriptor->other.descriptor_tag);\r
 438         printf("%s() descriptor_length error. %d\n", __FUNCTION__, descriptor->other.descriptor_length);\r
 439         result = 0;\r
 440 //        abort();\r
 441     }\r
 442     return result;\r
 443 }\r
 444 \r
 445 } // TS\r
 446 } // MPEG2