code.vuplus.com Git - vuplus_dvbapp/blob - lib/dvb/pvrparse.cpp

   1 #include <lib/dvb/pvrparse.h>
   2 #include <lib/base/eerror.h>
   3 #include <byteswap.h>
   4
   5 #ifndef BYTE_ORDER
   6 #error no byte order defined!
   7 #endif
   8
   9 eMPEGStreamInformation::eMPEGStreamInformation()
  10         : m_structure_cache_valid(0), m_structure_read(0), m_structure_write(0)
  11 {
  12 }
  13
  14 eMPEGStreamInformation::~eMPEGStreamInformation()
  15 {
  16         if (m_structure_read)
  17                 fclose(m_structure_read);
  18         if (m_structure_write)
  19                 fclose(m_structure_write);
  20 }
  21
  22 int eMPEGStreamInformation::startSave(const char *filename)
  23 {
  24         m_filename = filename;
  25         m_structure_write = fopen((m_filename + ".sc").c_str(), "wb");
  26         return 0;
  27 }
  28
  29 int eMPEGStreamInformation::stopSave(void)
  30 {
  31         if (m_structure_write)
  32         {
  33                 fclose(m_structure_write);
  34                 m_structure_write = 0;
  35         }
  36         if (m_filename == "")
  37                 return -1;
  38         FILE *f = fopen((m_filename + ".ap").c_str(), "wb");
  39         if (!f)
  40                 return -1;
  41
  42         for (std::map<off_t, pts_t>::const_iterator i(m_access_points.begin()); i != m_access_points.end(); ++i)
  43         {
  44                 unsigned long long d[2];
  45 #if BYTE_ORDER == BIG_ENDIAN
  46                 d[0] = i->first;
  47                 d[1] = i->second;
  48 #else
  49                 d[0] = bswap_64(i->first);
  50                 d[1] = bswap_64(i->second);
  51 #endif
  52                 fwrite(d, sizeof(d), 1, f);
  53         }
  54         fclose(f);
  55
  56         return 0;
  57 }
  58
  59 int eMPEGStreamInformation::load(const char *filename)
  60 {
  61         m_filename = filename;
  62         if (m_structure_read)
  63                 fclose(m_structure_read);
  64         m_structure_read = fopen((std::string(m_filename) + ".sc").c_str(), "rb");
  65         FILE *f = fopen((std::string(m_filename) + ".ap").c_str(), "rb");
  66         if (!f)
  67                 return -1;
  68         m_access_points.clear();
  69         m_pts_to_offset.clear();
  70         while (1)
  71         {
  72                 unsigned long long d[2];
  73                 if (fread(d, sizeof(d), 1, f) < 1)
  74                         break;
  75
  76 #if BYTE_ORDER == LITTLE_ENDIAN
  77                 d[0] = bswap_64(d[0]);
  78                 d[1] = bswap_64(d[1]);
  79 #endif
  80                 m_access_points[d[0]] = d[1];
  81                 m_pts_to_offset.insert(std::pair<pts_t,off_t>(d[1], d[0]));
  82         }
  83         fclose(f);
  84         fixupDiscontinuties();
  85         return 0;
  86 }
  87
  88 bool eMPEGStreamInformation::empty()
  89 {
  90         return m_access_points.empty();
  91 }
  92
  93 void eMPEGStreamInformation::fixupDiscontinuties()
  94 {
  95         m_timestamp_deltas.clear();
  96         if (!m_access_points.size())
  97                 return;
  98
  99 //      eDebug("Fixing discontinuities ...");
 100
 101                         /* if we have no delta at the beginning, extrapolate it */
 102         if ((m_access_points.find(0) == m_access_points.end()) && (m_access_points.size() > 1))
 103         {
 104                 std::map<off_t,pts_t>::const_iterator second = m_access_points.begin();
 105                 std::map<off_t,pts_t>::const_iterator first  = second++;
 106                 if (first->first < second->first) /* i.e., not equal or broken */
 107                 {
 108                         off_t diff = second->first - first->first;
 109                         pts_t tdiff = second->second - first->second;
 110                         tdiff *= first->first;
 111                         tdiff /= diff;
 112                         m_timestamp_deltas[0] = first->second - tdiff;
 113 //                      eDebug("first delta is %08llx", first->second - tdiff);
 114                 }
 115         }
 116
 117         if (m_timestamp_deltas.empty())
 118                 m_timestamp_deltas[m_access_points.begin()->first] = m_access_points.begin()->second;
 119
 120         pts_t currentDelta = m_timestamp_deltas.begin()->second, lastpts_t = 0;
 121         for (std::map<off_t,pts_t>::const_iterator i(m_access_points.begin()); i != m_access_points.end(); ++i)
 122         {
 123                 pts_t current = i->second - currentDelta;
 124                 pts_t diff = current - lastpts_t;
 125
 126                 if (llabs(diff) > (90000*10)) // 10sec diff
 127                 {
 128 //                      eDebug("%llx < %llx, have discont. new timestamp is %llx (diff is %llx)!", current, lastpts_t, i->second, diff);
 129                         currentDelta = i->second - lastpts_t; /* FIXME: should be the extrapolated new timestamp, based on the current rate */
 130 //                      eDebug("current delta now %llx, making current to %llx", currentDelta, i->second - currentDelta);
 131                         m_timestamp_deltas[i->first] = currentDelta;
 132                 }
 133                 lastpts_t = i->second - currentDelta;
 134         }
 135
 136
 137 //      eDebug("ok, found %d disconts.", m_timestamp_deltas.size());
 138
 139 #if 0
 140         for (off_t x=0x25807E34ULL; x < 0x25B3CF70; x+= 100000)
 141         {
 142                 off_t o = x;
 143                 pts_t p;
 144                 int r = getPTS(o, p);
 145                 eDebug("%08llx -> %08llx | %08llx, %d, %08llx %08llx", x, getDelta(x), getInterpolated(x), r, o, p);
 146         }
 147 #endif
 148 }
 149
 150 pts_t eMPEGStreamInformation::getDelta(off_t offset)
 151 {
 152         if (!m_timestamp_deltas.size())
 153                 return 0;
 154         std::map<off_t,pts_t>::iterator i = m_timestamp_deltas.upper_bound(offset);
 155
 156                 /* i can be the first when you query for something before the first PTS */
 157         if (i != m_timestamp_deltas.begin())
 158                 --i;
 159
 160         return i->second;
 161 }
 162
 163 int eMPEGStreamInformation::fixupPTS(const off_t &offset, pts_t &ts)
 164 {
 165         if (!m_timestamp_deltas.size())
 166                 return -1;
 167
 168         std::multimap<pts_t, off_t>::const_iterator
 169                 l = m_pts_to_offset.upper_bound(ts - 60 * 90000),
 170                 u = m_pts_to_offset.upper_bound(ts + 60 * 90000),
 171                 nearest = m_pts_to_offset.end();
 172
 173         while (l != u)
 174         {
 175                 if ((nearest == m_pts_to_offset.end()) || (llabs(l->first - ts) < llabs(nearest->first - ts)))
 176                         nearest = l;
 177                 ++l;
 178         }
 179         if (nearest == m_pts_to_offset.end())
 180                 return 1;
 181
 182         ts -= getDelta(nearest->second);
 183
 184         return 0;
 185 }
 186
 187 int eMPEGStreamInformation::getPTS(off_t &offset, pts_t &pts)
 188 {
 189         std::map<off_t,pts_t>::iterator before = m_access_points.lower_bound(offset);
 190
 191                 /* usually, we prefer the AP before the given offset. however if there is none, we take any. */
 192         if (before != m_access_points.begin())
 193                 --before;
 194
 195         if (before == m_access_points.end())
 196         {
 197                 pts = 0;
 198                 return -1;
 199         }
 200
 201         offset = before->first;
 202         pts = before->second - getDelta(offset);
 203
 204         return 0;
 205 }
 206
 207 pts_t eMPEGStreamInformation::getInterpolated(off_t offset)
 208 {
 209                 /* get the PTS values before and after the offset. */
 210         std::map<off_t,pts_t>::iterator before, after;
 211         after = m_access_points.upper_bound(offset);
 212         before = after;
 213
 214         if (before != m_access_points.begin())
 215                 --before;
 216         else    /* we query before the first known timestamp ... FIXME */
 217                 return 0;
 218
 219                 /* empty... */
 220         if (before == m_access_points.end())
 221                 return 0;
 222
 223                 /* if after == end, then we need to extrapolate ... FIXME */
 224         if ((before->first == offset) || (after == m_access_points.end()))
 225                 return before->second - getDelta(offset);
 226
 227         pts_t before_ts = before->second - getDelta(before->first);
 228         pts_t after_ts = after->second - getDelta(after->first);
 229
 230 //      eDebug("%08llx .. ? .. %08llx", before_ts, after_ts);
 231 //      eDebug("%08llx .. %08llx .. %08llx", before->first, offset, after->first);
 232
 233         pts_t diff = after_ts - before_ts;
 234         off_t diff_off = after->first - before->first;
 235
 236         diff = (offset - before->first) * diff / diff_off;
 237 //      eDebug("%08llx .. %08llx .. %08llx", before_ts, before_ts + diff, after_ts);
 238         return before_ts + diff;
 239 }
 240
 241 off_t eMPEGStreamInformation::getAccessPoint(pts_t ts, int marg)
 242 {
 243                 /* FIXME: more efficient implementation */
 244         off_t last = 0;
 245         off_t last2 = 0;
 246         pts_t lastc = 0;
 247         ts += 1; // Add rounding error margin
 248         for (std::map<off_t, pts_t>::const_iterator i(m_access_points.begin()); i != m_access_points.end(); ++i)
 249         {
 250                 pts_t delta = getDelta(i->first);
 251                 pts_t c = i->second - delta;
 252                 if (c > ts) {
 253                         if (marg > 0)
 254                                 return (last + i->first)/376*188;
 255                         else if (marg < 0)
 256                                 return (last + last2)/376*188;
 257                         else
 258                                 return last;
 259                 }
 260                 lastc = c;
 261                 last2 = last;
 262                 last = i->first;
 263         }
 264         if (marg < 0)
 265                 return (last + last2)/376*188;
 266         else
 267                 return last;
 268 }
 269
 270 int eMPEGStreamInformation::getNextAccessPoint(pts_t &ts, const pts_t &start, int direction)
 271 {
 272         off_t offset = getAccessPoint(start);
 273         pts_t c1, c2;
 274         std::map<off_t, pts_t>::const_iterator i = m_access_points.find(offset);
 275         if (i == m_access_points.end())
 276         {
 277                 eDebug("getNextAccessPoint: initial AP not found");
 278                 return -1;
 279         }
 280         c1 = i->second - getDelta(i->first);
 281         while (direction)
 282         {
 283                 if (direction > 0)
 284                 {
 285                         if (i == m_access_points.end())
 286                                 return -1;
 287                         ++i;
 288                         c2 = i->second - getDelta(i->first);
 289                         if (c1 == c2) { // Discontinuity
 290                                 ++i;
 291                                 c2 = i->second - getDelta(i->first);
 292                         }
 293                         c1 = c2;
 294                         direction--;
 295                 }
 296                 if (direction < 0)
 297                 {
 298                         if (i == m_access_points.begin())
 299                         {
 300                                 eDebug("at start");
 301                                 return -1;
 302                         }
 303                         --i;
 304                         c2 = i->second - getDelta(i->first);
 305                         if (c1 == c2) { // Discontinuity
 306                                 --i;
 307                                 c2 = i->second - getDelta(i->first);
 308                         }
 309                         c1 = c2;
 310                         direction++;
 311                 }
 312         }
 313         ts = i->second - getDelta(i->first);
 314         eDebug("fine, at %llx - %llx = %llx", ts, i->second, getDelta(i->first));
 315         eDebug("fine, at %lld - %lld = %lld", ts, i->second, getDelta(i->first));
 316         return 0;
 317 }
 318
 319 void eMPEGStreamInformation::writeStructureEntry(off_t offset, structure_data data)
 320 {
 321         unsigned long long d[2];
 322 #if BYTE_ORDER == BIG_ENDIAN
 323         d[0] = offset;
 324         d[1] = data;
 325 #else
 326         d[0] = bswap_64(offset);
 327         d[1] = bswap_64(data);
 328 #endif
 329         if (m_structure_write)
 330                 fwrite(d, sizeof(d), 1, m_structure_write);
 331 }
 332
 333 int eMPEGStreamInformation::getStructureEntry(off_t &offset, unsigned long long &data, int get_next)
 334 {
 335         if (!m_structure_read)
 336         {
 337                 eDebug("getStructureEntry failed because of no m_structure_read");
 338                 return -1;
 339         }
 340
 341         const int struture_cache_entries = sizeof(m_structure_cache) / 16;
 342         if ((!m_structure_cache_valid) || ((off_t)m_structure_cache[0] > offset) || ((off_t)m_structure_cache[(struture_cache_entries - (get_next ? 2 : 1)) * 2] <= offset))
 343         {
 344                 fseek(m_structure_read, 0, SEEK_END);
 345                 int l = ftell(m_structure_read);
 346                 unsigned long long d[2];
 347                 const int entry_size = sizeof d;
 348
 349                         /* do a binary search */
 350                 int count = l / entry_size;
 351                 int i = 0;
 352
 353                 while (count)
 354                 {
 355                         int step = count >> 1;
 356
 357                         fseek(m_structure_read, (i + step) * entry_size, SEEK_SET);
 358                         if (!fread(d, 1, entry_size, m_structure_read))
 359                         {
 360                                 eDebug("read error at entry %d", i);
 361                                 return -1;
 362                         }
 363
 364 #if BYTE_ORDER != BIG_ENDIAN
 365                         d[0] = bswap_64(d[0]);
 366                         d[1] = bswap_64(d[1]);
 367 #endif
 368 //                      eDebug("%d: %08llx > %llx", i, d[0], d[1]);
 369
 370                         if (d[0] < (unsigned long long)offset)
 371                         {
 372                                 i += step + 1;
 373                                 count -= step + 1;
 374                         } else
 375                                 count = step;
 376                 }
 377
 378                 eDebug("found %d", i);
 379
 380                         /* put that in the middle */
 381                 i -= struture_cache_entries / 2;
 382                 if (i < 0)
 383                         i = 0;
 384                 eDebug("cache starts at %d", i);
 385                 fseek(m_structure_read, i * entry_size, SEEK_SET);
 386                 int num = fread(m_structure_cache, entry_size, struture_cache_entries, m_structure_read);
 387                 eDebug("%d entries", num);
 388                 for (i = 0; i < struture_cache_entries; ++i)
 389                 {
 390                         if (i < num)
 391                         {
 392 #if BYTE_ORDER != BIG_ENDIAN
 393                                 m_structure_cache[i * 2] = bswap_64(m_structure_cache[i * 2]);
 394                                 m_structure_cache[i * 2 + 1] = bswap_64(m_structure_cache[i * 2 + 1]);
 395 #endif
 396                         } else
 397                         {
 398                                 m_structure_cache[i * 2] = 0x7fffffffffffffffULL; /* fill with harmless content */
 399                                 m_structure_cache[i * 2 + 1] = 0;
 400                         }
 401                 }
 402                 m_structure_cache_valid = 1;
 403         }
 404
 405         int i = 0;
 406         while ((off_t)m_structure_cache[i * 2] <= offset)
 407         {
 408                 ++i;
 409                 if (i == struture_cache_entries)
 410                 {
 411                         eDebug("structure data consistency fail!, we are looking for %llx, but last entry is %llx", offset, m_structure_cache[i*2-2]);
 412                         return -1;
 413                 }
 414         }
 415         if (!i)
 416         {
 417                 eDebug("structure data (first entry) consistency fail!");
 418                 return -1;
 419         }
 420
 421         if (!get_next)
 422                 --i;
 423
 424 //      eDebug("[%d] looked for %lld, found %llu=%llx", sizeof offset, offset, m_structure_cache[i * 2], m_structure_cache[i * 2 + 1]);
 425         offset = m_structure_cache[i * 2];
 426         data = m_structure_cache[i * 2 + 1];
 427         return 0;
 428 }
 429
 430 int eMPEGStreamInformation::getStructureEntry_next(off_t &offset, unsigned long long &data)
 431 {
 432         if (!m_structure_read)
 433         {
 434                 eDebug("getStructureEntry failed because of no m_structure_read");
 435                 return -1;
 436         }
 437
 438         off_t _offset = offset;
 439         const int struture_cache_entries = sizeof(m_structure_cache) / 16;
 440         if ((!m_structure_cache_valid) || ((off_t)m_structure_cache[0] > offset) || ((off_t)m_structure_cache[(struture_cache_entries - 1)*2] <= offset))
 441         {
 442                 if(update_structure_cache_entries(_offset))
 443                 {
 444                         return -1;
 445                 }
 446         }
 447
 448         int i = 0;
 449         while ((off_t)m_structure_cache[i * 2] <= offset)
 450         {
 451                 ++i;
 452                 if (i == struture_cache_entries)
 453                 {
 454                         eDebug("structure data consistency fail!, we are looking for %llu, but last entry is %llu", offset, m_structure_cache[(struture_cache_entries-1)*2]);
 455                         return -1;
 456                 }
 457         }
 458         if (!i)
 459         {
 460                 eDebug("structure data (first entry) consistency fail!");
 461                 return -1;
 462         }
 463
 464 //      eDebug("[%d] looked for %llu, found data %llu=%llx",sizeof offset, offset, m_structure_cache[i * 2], m_structure_cache[i * 2 + 1]);
 465         offset = m_structure_cache[i * 2];
 466         data = m_structure_cache[i * 2 + 1];
 467         return 0;
 468 }
 469
 470 int eMPEGStreamInformation::getStructureEntry_prev(off_t &offset, unsigned long long &data)
 471 {
 472         if (!m_structure_read)
 473         {
 474                 eDebug("getStructureEntry failed because of no m_structure_read");
 475                 return -1;
 476         }
 477
 478         off_t _offset = offset;
 479         const int struture_cache_entries = sizeof(m_structure_cache) / 16;
 480         if ((!m_structure_cache_valid) || ((off_t)m_structure_cache[0] >= offset) || ((off_t)m_structure_cache[(struture_cache_entries - 1)*2] < offset))
 481         {
 482                 if(update_structure_cache_entries(_offset))
 483                 {
 484                         return -1;
 485                 }
 486         }
 487
 488         int i = struture_cache_entries-1;
 489         while ((off_t)m_structure_cache[i * 2] >= offset)
 490         {
 491                 if (i <= 0)
 492                 {
 493                         eDebug("structure data consistency fail!, we are looking for %llu, but last entry is %llu", offset, m_structure_cache[i * 2]);
 494                         return -1;
 495                 }
 496                 --i;
 497         }
 498         if (i == struture_cache_entries-1)
 499         {
 500                 eDebug("structure data (first entry) consistency fail!");
 501                 return -1;
 502         }
 503
 504 //      eDebug("[%d] looked for %llu, found data %llu=%llx",sizeof offset, offset, m_structure_cache[i * 2], m_structure_cache[i * 2 + 1]);
 505         offset = m_structure_cache[i * 2];
 506         data = m_structure_cache[i * 2 + 1];
 507         return 0;
 508 }
 509
 510 int eMPEGStreamInformation::update_structure_cache_entries(off_t offset)
 511 {
 512         const int struture_cache_entries = sizeof(m_structure_cache) / 16;
 513         fseek(m_structure_read, 0, SEEK_END);
 514         int l = ftell(m_structure_read);
 515         unsigned long long d[2];
 516         const int entry_size = sizeof d;
 517
 518                 /* do a binary search */
 519         int count = l / entry_size;
 520         int i = 0;
 521
 522         while (count)
 523         {
 524                 int step = count >> 1;
 525                 fseek(m_structure_read, (i + step) * entry_size, SEEK_SET);
 526                 if (!fread(d, 1, entry_size, m_structure_read))
 527                 {
 528                         eDebug("read error at entry %d", i);
 529                         return -1;
 530                 }
 531 #if BYTE_ORDER != BIG_ENDIAN
 532                 d[0] = bswap_64(d[0]);
 533                 d[1] = bswap_64(d[1]);
 534 #endif
 535 //              eDebug("%d: %08llx > %llx", i, d[0], d[1]);
 536                 if (d[0] < (unsigned long long)offset)
 537                 {
 538                         i += step + 1;
 539                         count -= step + 1;
 540                 } else
 541                         count = step;
 542         }
 543         eDebug("found %d", i);
 544
 545         /* put that in the middle */
 546         i -= struture_cache_entries / 2;
 547         if (i < 0)
 548                 i = 0;
 549         eDebug("cache starts at %d", i);
 550         fseek(m_structure_read, i * entry_size, SEEK_SET);
 551         int num = fread(m_structure_cache, entry_size, struture_cache_entries, m_structure_read);
 552         eDebug("%d entries", num);
 553         for (i = 0; i < struture_cache_entries; ++i)
 554         {
 555                 if (i < num)
 556                 {
 557 #if BYTE_ORDER != BIG_ENDIAN
 558                         m_structure_cache[i * 2] = bswap_64(m_structure_cache[i * 2]);
 559                         m_structure_cache[i * 2 + 1] = bswap_64(m_structure_cache[i * 2 + 1]);
 560 #endif
 561                 } else
 562                 {
 563                         m_structure_cache[i * 2] = 0x7fffffffffffffffULL; /* fill with harmless content */
 564                         m_structure_cache[i * 2 + 1] = 0x7fffffffffffffffULL;
 565                 }
 566         }
 567         m_structure_cache_valid = 1;
 568         return 0;
 569 }
 570
 571 eMPEGStreamParserTS::eMPEGStreamParserTS(eMPEGStreamInformation &streaminfo): m_streaminfo(streaminfo), m_pktptr(0), m_pid(-1), m_need_next_packet(0), m_skip(0), m_last_pts_valid(0)
 572 {
 573 }
 574
 575 int eMPEGStreamParserTS::processPacket(const unsigned char *pkt, off_t offset)
 576 {
 577         if (!wantPacket(pkt))
 578                 eWarning("something's wrong.");
 579
 580         const unsigned char *end = pkt + 188, *begin = pkt;
 581
 582         int pusi = !!(pkt[1] & 0x40);
 583
 584         if (!(pkt[3] & 0x10)) /* no payload? */
 585                 return 0;
 586
 587         if (pkt[3] & 0x20) // adaptation field present?
 588                 pkt += pkt[4] + 4 + 1;  /* skip adaptation field and header */
 589         else
 590                 pkt += 4; /* skip header */
 591
 592         if (pkt > end)
 593         {
 594                 eWarning("[TSPARSE] dropping huge adaption field");
 595                 return 0;
 596         }
 597
 598         pts_t pts = 0;
 599         int ptsvalid = 0;
 600
 601         if (pusi)
 602         {
 603                         // ok, we now have the start of the payload, aligned with the PES packet start.
 604                 if (pkt[0] || pkt[1] || (pkt[2] != 1))
 605                 {
 606                         eWarning("broken startcode");
 607                         return 0;
 608                 }
 609
 610                 if (pkt[7] & 0x80) // PTS present?
 611                 {
 612                         pts  = ((unsigned long long)(pkt[ 9]&0xE))  << 29;
 613                         pts |= ((unsigned long long)(pkt[10]&0xFF)) << 22;
 614                         pts |= ((unsigned long long)(pkt[11]&0xFE)) << 14;
 615                         pts |= ((unsigned long long)(pkt[12]&0xFF)) << 7;
 616                         pts |= ((unsigned long long)(pkt[13]&0xFE)) >> 1;
 617                         ptsvalid = 1;
 618
 619                         m_last_pts = pts;
 620                         m_last_pts_valid = 1;
 621
 622         #if 0
 623                         int sec = pts / 90000;
 624                         int frm = pts % 90000;
 625                         int min = sec / 60;
 626                         sec %= 60;
 627                         int hr = min / 60;
 628                         min %= 60;
 629                         int d = hr / 24;
 630                         hr %= 24;
 631
 632                         eDebug("pts: %016llx %d:%02d:%02d:%02d:%05d", pts, d, hr, min, sec, frm);
 633         #endif
 634                 }
 635
 636                         /* advance to payload */
 637                 pkt += pkt[8] + 9;
 638         }
 639
 640         while (pkt < (end-4))
 641         {
 642                 int pkt_offset = pkt - begin;
 643                 if (!(pkt[0] || pkt[1] || (pkt[2] != 1)))
 644                 {
 645 //                      eDebug("SC %02x %02x %02x %02x, %02x", pkt[0], pkt[1], pkt[2], pkt[3], pkt[4]);
 646                         int sc = pkt[3];
 647
 648                         if (m_streamtype == 0) /* mpeg2 */
 649                         {
 650                                 if ((sc == 0x00) || (sc == 0xb3) || (sc == 0xb8)) /* picture, sequence, group start code */
 651                                 {
 652                                         unsigned long long data = sc | (pkt[4] << 8) | (pkt[5] << 16) | (pkt[6] << 24);
 653                                         m_streaminfo.writeStructureEntry(offset + pkt_offset, data  & 0xFFFFFFFFULL);
 654                                 }
 655                                 if (pkt[3] == 0xb3) /* sequence header */
 656                                 {
 657                                         if (ptsvalid)
 658                                         {
 659                                                 m_streaminfo.m_access_points[offset] = pts;
 660         //                                      eDebug("Sequence header at %llx, pts %llx", offset, pts);
 661                                         } else
 662                                                 /*eDebug("Sequence header but no valid PTS value.")*/;
 663                                 }
 664                         }
 665
 666                         if (m_streamtype == 1) /* H.264 */
 667                         {
 668                                 if (sc == 0x09)
 669                                 {
 670                                                 /* store image type */
 671                                         unsigned long long data = sc | (pkt[4] << 8);
 672                                         m_streaminfo.writeStructureEntry(offset + pkt_offset, data);
 673                                 }
 674                                 if (pkt[3] == 0x09 &&   /* MPEG4 AVC NAL unit access delimiter */
 675                                          (pkt[4] >> 5) == 0) /* and I-frame */
 676                                 {
 677                                         if (ptsvalid)
 678                                         {
 679                                                 m_streaminfo.m_access_points[offset] = pts;
 680         //                              eDebug("MPEG4 AVC UAD at %llx, pts %llx", offset, pts);
 681                                         } else
 682                                                 /*eDebug("MPEG4 AVC UAD but no valid PTS value.")*/;
 683                                 }
 684                         }
 685                 }
 686                 ++pkt;
 687         }
 688         return 0;
 689 }
 690
 691 inline int eMPEGStreamParserTS::wantPacket(const unsigned char *hdr) const
 692 {
 693         if (hdr[0] != 0x47)
 694         {
 695                 eDebug("missing sync!");
 696                 return 0;
 697         }
 698         int ppid = ((hdr[1]&0x1F) << 8) | hdr[2];
 699
 700         if (ppid != m_pid)
 701                 return 0;
 702
 703         if (m_need_next_packet)  /* next packet (on this pid) was required? */
 704                 return 1;
 705
 706         if (hdr[1] & 0x40)       /* pusi set: yes. */
 707                 return 1;
 708
 709         return m_streamtype == 0; /* we need all packets for MPEG2, but only PUSI packets for H.264 */
 710 }
 711
 712 void eMPEGStreamParserTS::parseData(off_t offset, const void *data, unsigned int len)
 713 {
 714         const unsigned char *packet = (const unsigned char*)data;
 715         const unsigned char *packet_start = packet;
 716
 717                         /* sorry for the redundant code here, but there are too many special cases... */
 718         while (len)
 719         {
 720                         /* emergency resync. usually, this should not happen, because the data should
 721                            be sync-aligned.
 722
 723                            to make this code work for non-strictly-sync-aligned data, (for example, bad
 724                            files) we fix a possible resync here by skipping data until the next 0x47.
 725
 726                            if this is a false 0x47, the packet will be dropped by wantPacket, and the
 727                            next time, sync will be re-established. */
 728                 int skipped = 0;
 729                 while (!m_pktptr && len)
 730                 {
 731                         if (packet[0] == 0x47)
 732                                 break;
 733                         len--;
 734                         packet++;
 735                         skipped++;
 736                 }
 737
 738                 if (skipped)
 739                         eDebug("SYNC LOST: skipped %d bytes.", skipped);
 740
 741                 if (!len)
 742                         break;
 743
 744                 if (m_pktptr)
 745                 {
 746                                 /* skip last packet */
 747                         if (m_pktptr < 0)
 748                         {
 749                                 unsigned int skiplen = -m_pktptr;
 750                                 if (skiplen > len)
 751                                         skiplen = len;
 752                                 packet += skiplen;
 753                                 len -= skiplen;
 754                                 m_pktptr += skiplen;
 755                                 continue;
 756                         } else if (m_pktptr < 4) /* header not complete, thus we don't know if we want this packet */
 757                         {
 758                                 unsigned int storelen = 4 - m_pktptr;
 759                                 if (storelen > len)
 760                                         storelen = len;
 761                                 memcpy(m_pkt + m_pktptr, packet,  storelen);
 762
 763                                 m_pktptr += storelen;
 764                                 len -= storelen;
 765                                 packet += storelen;
 766
 767                                 if (m_pktptr == 4)
 768                                         if (!wantPacket(m_pkt))
 769                                         {
 770                                                         /* skip packet */
 771                                                 packet += 184;
 772                                                 len -= 184;
 773                                                 m_pktptr = 0;
 774                                                 continue;
 775                                         }
 776                         }
 777                                 /* otherwise we complete up to the full packet */
 778                         unsigned int storelen = 188 - m_pktptr;
 779                         if (storelen > len)
 780                                 storelen = len;
 781                         memcpy(m_pkt + m_pktptr, packet,  storelen);
 782                         m_pktptr += storelen;
 783                         len -= storelen;
 784                         packet += storelen;
 785
 786                         if (m_pktptr == 188)
 787                         {
 788                                 m_need_next_packet = processPacket(m_pkt, offset + (packet - packet_start));
 789                                 m_pktptr = 0;
 790                         }
 791                 } else if (len >= 4)  /* if we have a full header... */
 792                 {
 793                         if (wantPacket(packet))  /* decide wheter we need it ... */
 794                         {
 795                                 if (len >= 188)          /* packet complete? */
 796                                 {
 797                                         m_need_next_packet = processPacket(packet, offset + (packet - packet_start)); /* process it now. */
 798                                 } else
 799                                 {
 800                                         memcpy(m_pkt, packet, len);  /* otherwise queue it up */
 801                                         m_pktptr = len;
 802                                 }
 803                         }
 804
 805                                 /* skip packet */
 806                         int sk = len;
 807                         if (sk >= 188)
 808                                 sk = 188;
 809                         else if (!m_pktptr) /* we dont want this packet, otherwise m_pktptr = sk (=len) > 4 */
 810                                 m_pktptr = sk - 188;
 811
 812                         len -= sk;
 813                         packet += sk;
 814                 } else             /* if we don't have a complete header */
 815                 {
 816                         memcpy(m_pkt, packet, len);   /* complete header next time */
 817                         m_pktptr = len;
 818                         packet += len;
 819                         len = 0;
 820                 }
 821         }
 822 }
 823
 824 void eMPEGStreamParserTS::setPid(int _pid, int type)
 825 {
 826         m_pktptr = 0;
 827         m_pid = _pid;
 828         m_streamtype = type;
 829 }
 830
 831 int eMPEGStreamParserTS::getLastPTS(pts_t &last_pts)
 832 {
 833         if (!m_last_pts_valid)
 834         {
 835                 last_pts = 0;
 836                 return -1;
 837         }
 838         last_pts = m_last_pts;
 839         return 0;
 840 }
 841