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 int eMPEGStreamInformation::save(const char *filename)
  10 {
  11         FILE *f = fopen(filename, "wb");
  12         if (!f)
  13                 return -1;
  14
  15         for (std::map<off_t, pts_t>::const_iterator i(m_access_points.begin()); i != m_access_points.end(); ++i)
  16         {
  17                 unsigned long long d[2];
  18 #if BYTE_ORDER == BIG_ENDIAN
  19                 d[0] = i->first;
  20                 d[1] = i->second;
  21 #else
  22                 d[0] = bswap_64(i->first);
  23                 d[1] = bswap_64(i->second);
  24 #endif
  25                 fwrite(d, sizeof(d), 1, f);
  26         }
  27         fclose(f);
  28
  29         return 0;
  30 }
  31
  32 int eMPEGStreamInformation::load(const char *filename)
  33 {
  34         FILE *f = fopen(filename, "rb");
  35         if (!f)
  36                 return -1;
  37         m_access_points.clear();
  38         while (1)
  39         {
  40                 unsigned long long d[2];
  41                 if (fread(d, sizeof(d), 1, f) < 1)
  42                         break;
  43
  44 #if BYTE_ORDER == LITTLE_ENDIAN
  45                 d[0] = bswap_64(d[0]);
  46                 d[1] = bswap_64(d[1]);
  47 #endif
  48                 m_access_points[d[0]] = d[1];
  49         }
  50         fclose(f);
  51         fixupDiscontinuties();
  52         return 0;
  53 }
  54
  55 bool eMPEGStreamInformation::empty()
  56 {
  57         return m_access_points.empty();
  58 }
  59
  60 void eMPEGStreamInformation::fixupDiscontinuties()
  61 {
  62         m_timestamp_deltas.clear();
  63         if (!m_access_points.size())
  64                 return;
  65
  66 //      eDebug("Fixing discontinuities ...");
  67
  68                         /* if we have no delta at the beginning, extrapolate it */
  69         if ((m_access_points.find(0) == m_access_points.end()) && (m_access_points.size() > 1))
  70         {
  71                 std::map<off_t,pts_t>::const_iterator second = m_access_points.begin();
  72                 std::map<off_t,pts_t>::const_iterator first  = second++;
  73                 if (first->first < second->first) /* i.e., not equal or broken */
  74                 {
  75                         off_t diff = second->first - first->first;
  76                         pts_t tdiff = second->second - first->second;
  77                         tdiff *= first->first;
  78                         tdiff /= diff;
  79                         m_timestamp_deltas[0] = first->second - tdiff;
  80 //                      eDebug("first delta is %08llx", first->second - tdiff);
  81                 }
  82         }
  83
  84         if (m_timestamp_deltas.empty())
  85                 m_timestamp_deltas[m_access_points.begin()->first] = m_access_points.begin()->second;
  86
  87         pts_t currentDelta = m_timestamp_deltas.begin()->second, lastpts_t = 0;
  88         for (std::map<off_t,pts_t>::const_iterator i(m_access_points.begin()); i != m_access_points.end(); ++i)
  89         {
  90                 pts_t current = i->second - currentDelta;
  91                 pts_t diff = current - lastpts_t;
  92
  93                 if (llabs(diff) > (90000*5)) // 5sec diff
  94                 {
  95 //                      eDebug("%llx < %llx, have discont. new timestamp is %llx (diff is %llx)!", current, lastpts_t, i->second, diff);
  96                         currentDelta = i->second - lastpts_t; /* FIXME: should be the extrapolated new timestamp, based on the current rate */
  97 //                      eDebug("current delta now %llx, making current to %llx", currentDelta, i->second - currentDelta);
  98                         m_timestamp_deltas[i->first] = currentDelta;
  99                 }
 100                 lastpts_t = i->second - currentDelta;
 101         }
 102
 103
 104 //      eDebug("ok, found %d disconts.", m_timestamp_deltas.size());
 105
 106 #if 0
 107         for (off_t x=0x25807E34ULL; x < 0x25B3CF70; x+= 100000)
 108         {
 109                 off_t o = x;
 110                 pts_t p;
 111                 int r = getPTS(o, p);
 112                 eDebug("%08llx -> %08llx | %08llx, %d, %08llx %08llx", x, getDelta(x), getInterpolated(x), r, o, p);
 113         }
 114 #endif
 115 }
 116
 117 pts_t eMPEGStreamInformation::getDelta(off_t offset)
 118 {
 119         if (!m_timestamp_deltas.size())
 120                 return 0;
 121         std::map<off_t,pts_t>::iterator i = m_timestamp_deltas.upper_bound(offset);
 122
 123                 /* i can be the first when you query for something before the first PTS */
 124         if (i != m_timestamp_deltas.begin())
 125                 --i;
 126
 127         return i->second;
 128 }
 129
 130 int eMPEGStreamInformation::fixupPTS(const off_t &offset, pts_t &ts)
 131 {
 132         if (!m_timestamp_deltas.size())
 133                 return -1;
 134
 135         std::map<off_t, pts_t>::const_iterator i = m_access_points.upper_bound(offset - 4 * 1024 * 1024), nearest = m_access_points.end();
 136
 137         while (i != m_access_points.end())
 138         {
 139                 if ((nearest == m_access_points.end()) || (llabs(i->second - ts) < llabs(nearest->second - ts)))
 140                         nearest = i;
 141                 ++i;
 142         }
 143         if (nearest == m_access_points.end())
 144                 return -1;
 145         ts -= getDelta(nearest->first);
 146         return 0;
 147 }
 148
 149 int eMPEGStreamInformation::getPTS(off_t &offset, pts_t &pts)
 150 {
 151         std::map<off_t,pts_t>::iterator before = m_access_points.lower_bound(offset);
 152
 153                 /* usually, we prefer the AP before the given offset. however if there is none, we take any. */
 154         if (before != m_access_points.begin())
 155                 --before;
 156
 157         if (before == m_access_points.end())
 158         {
 159                 pts = 0;
 160                 return -1;
 161         }
 162
 163         offset = before->first;
 164         pts = before->second - getDelta(offset);
 165
 166         return 0;
 167 }
 168
 169 pts_t eMPEGStreamInformation::getInterpolated(off_t offset)
 170 {
 171                 /* get the PTS values before and after the offset. */
 172         std::map<off_t,pts_t>::iterator before, after;
 173
 174         after = m_access_points.upper_bound(offset);
 175         before = after;
 176
 177         if (before != m_access_points.begin())
 178                 --before;
 179         else    /* we query before the first known timestamp ... FIXME */
 180                 return 0;
 181
 182                 /* empty... */
 183         if (before == m_access_points.end())
 184                 return 0;
 185
 186                 /* if after == end, then we need to extrapolate ... FIXME */
 187         if ((before->first == offset) || (after == m_access_points.end()))
 188                 return before->second - getDelta(offset);
 189
 190         pts_t before_ts = before->second - getDelta(before->first);
 191         pts_t after_ts = after->second - getDelta(after->first);
 192
 193 //      eDebug("%08llx .. ? .. %08llx", before_ts, after_ts);
 194 //      eDebug("%08llx .. %08llx .. %08llx", before->first, offset, after->first);
 195
 196         pts_t diff = after_ts - before_ts;
 197         off_t diff_off = after->first - before->first;
 198
 199         diff = (offset - before->first) * diff / diff_off;
 200 //      eDebug("%08llx .. %08llx .. %08llx", before_ts, before_ts + diff, after_ts);
 201         return before_ts + diff;
 202 }
 203
 204 off_t eMPEGStreamInformation::getAccessPoint(pts_t ts)
 205 {
 206                 /* FIXME: more efficient implementation */
 207         pts_t delta = 0;
 208         off_t last = 0;
 209         for (std::map<off_t, pts_t>::const_iterator i(m_access_points.begin()); i != m_access_points.end(); ++i)
 210         {
 211                 pts_t delta = getDelta(i->first);
 212                 pts_t c = i->second - delta;
 213                 if (c > ts)
 214                         break;
 215                 last = i->first;
 216         }
 217         return last;
 218 }
 219
 220 int eMPEGStreamInformation::getNextAccessPoint(pts_t &ts, const pts_t &start, int direction)
 221 {
 222         off_t offset = getAccessPoint(start);
 223         std::map<off_t, pts_t>::const_iterator i = m_access_points.find(offset);
 224         if (i == m_access_points.end())
 225         {
 226                 eDebug("getNextAccessPoint: initial AP not found");
 227                 return -1;
 228         }
 229         while (direction)
 230         {
 231                 if (direction > 0)
 232                 {
 233                         if (i == m_access_points.end())
 234                                 return -1;
 235                         ++i;
 236                         direction--;
 237                 }
 238                 if (direction < 0)
 239                 {
 240                         if (i == m_access_points.begin())
 241                         {
 242                                 eDebug("at start");
 243                                 return -1;
 244                         }
 245                         --i;
 246                         direction++;
 247                 }
 248         }
 249         ts = i->second - getDelta(i->first);
 250         eDebug("fine, at %llx - %llx = %llx", ts, i->second, getDelta(i->first));
 251         eDebug("fine, at %lld - %lld = %lld", ts, i->second, getDelta(i->first));
 252         return 0;
 253 }
 254
 255 eMPEGStreamParserTS::eMPEGStreamParserTS(eMPEGStreamInformation &streaminfo): m_streaminfo(streaminfo), m_pktptr(0), m_pid(-1), m_need_next_packet(0), m_skip(0)
 256 {
 257 }
 258
 259 int eMPEGStreamParserTS::processPacket(const unsigned char *pkt, off_t offset)
 260 {
 261         if (!wantPacket(pkt))
 262                 eWarning("something's wrong.");
 263
 264         const unsigned char *end = pkt + 188;
 265
 266         if (!(pkt[3] & 0x10))
 267         {
 268                 eWarning("[TSPARSE] PUSI set but no payload.");
 269                 return 0;
 270         }
 271
 272         if (pkt[3] & 0x20) // adaption field present?
 273                 pkt += pkt[4] + 4 + 1;  /* skip adaption field and header */
 274         else
 275                 pkt += 4; /* skip header */
 276
 277         if (pkt > end)
 278         {
 279                 eWarning("[TSPARSE] dropping huge adaption field");
 280                 return 0;
 281         }
 282
 283                 // ok, we now have the start of the payload, aligned with the PES packet start.
 284         if (pkt[0] || pkt[1] || (pkt[2] != 1))
 285         {
 286                 eWarning("broken startcode");
 287                 return 0;
 288         }
 289
 290
 291         pts_t pts = 0;
 292         int ptsvalid = 0;
 293
 294         if (pkt[7] & 0x80) // PTS present?
 295         {
 296                 pts  = ((unsigned long long)(pkt[ 9]&0xE))  << 29;
 297                 pts |= ((unsigned long long)(pkt[10]&0xFF)) << 22;
 298                 pts |= ((unsigned long long)(pkt[11]&0xFE)) << 14;
 299                 pts |= ((unsigned long long)(pkt[12]&0xFF)) << 7;
 300                 pts |= ((unsigned long long)(pkt[13]&0xFE)) >> 1;
 301                 ptsvalid = 1;
 302
 303 #if 0
 304                 int sec = pts / 90000;
 305                 int frm = pts % 90000;
 306                 int min = sec / 60;
 307                 sec %= 60;
 308                 int hr = min / 60;
 309                 min %= 60;
 310                 int d = hr / 24;
 311                 hr %= 24;
 312
 313                 eDebug("pts: %016llx %d:%02d:%02d:%02d:%05d", pts, d, hr, min, sec, frm);
 314 #endif
 315         }
 316
 317                 /* advance to payload */
 318         pkt += pkt[8] + 9;
 319
 320                 /* sometimes, there are zeros before the startcode. */
 321         while (pkt < (end-4))
 322                 if (pkt[0] || pkt[1] || pkt[2])
 323                         break;
 324                 else
 325                         pkt++;
 326
 327                 /* if startcode found */
 328 //      eDebug("%02x %02x %02x %02x", pkt[0], pkt[1], pkt[2], pkt[3]);
 329         if (!(pkt[0] || pkt[1] || (pkt[2] != 1)))
 330         {
 331                 if (pkt[3] == 0xb3) /* sequence header */
 332                 {
 333                         if (ptsvalid)
 334                         {
 335                                 m_streaminfo.m_access_points[offset] = pts;
 336                                 eDebug("Sequence header at %llx, pts %llx", offset, pts);
 337                         } else
 338                                 eDebug("Sequence header but no valid PTS value.");
 339                 }
 340
 341                 if (pkt[3] == 0x09) /* MPEG4 AVC unit access delimiter */
 342                 {
 343                         if (ptsvalid)
 344                         {
 345                                 m_streaminfo.m_access_points[offset] = pts;
 346                                 eDebug("MPEG4 AVC UAD at %llx, pts %llx", offset, pts);
 347                         } else
 348                                 eDebug("MPEG4 AVC UAD but no valid PTS value.");
 349                 }
 350         }
 351         return 0;
 352 }
 353
 354 inline int eMPEGStreamParserTS::wantPacket(const unsigned char *hdr) const
 355 {
 356         if (hdr[0] != 0x47)
 357         {
 358                 eDebug("missing sync!");
 359                 return 0;
 360         }
 361         int ppid = ((hdr[1]&0x1F) << 8) | hdr[2];
 362
 363         if (ppid != m_pid)
 364                 return 0;
 365
 366         if (m_need_next_packet)  /* next packet (on this pid) was required? */
 367                 return 1;
 368
 369         if (hdr[1] & 0x40)       /* pusi set: yes. */
 370                 return 1;
 371
 372         return 0;
 373 }
 374
 375 void eMPEGStreamParserTS::parseData(off_t offset, const void *data, unsigned int len)
 376 {
 377         const unsigned char *packet = (const unsigned char*)data;
 378         const unsigned char *packet_start = packet;
 379
 380                         /* sorry for the redundant code here, but there are too many special cases... */
 381         while (len)
 382         {
 383                         /* emergency resync. usually, this should not happen, because the data should
 384                            be sync-aligned.
 385
 386                            to make this code work for non-strictly-sync-aligned data, (for example, bad
 387                            files) we fix a possible resync here by skipping data until the next 0x47.
 388
 389                            if this is a false 0x47, the packet will be dropped by wantPacket, and the
 390                            next time, sync will be re-established. */
 391                 int skipped = 0;
 392                 while (!m_pktptr && len)
 393                 {
 394                         if (packet[0] == 0x47)
 395                                 break;
 396                         len--;
 397                         packet++;
 398                         skipped++;
 399                 }
 400
 401                 if (skipped)
 402                         eDebug("SYNC LOST: skipped %d bytes.", skipped);
 403
 404                 if (!len)
 405                         break;
 406
 407                 if (m_pktptr)
 408                 {
 409                                 /* skip last packet */
 410                         if (m_pktptr < 0)
 411                         {
 412                                 unsigned int skiplen = -m_pktptr;
 413                                 if (skiplen > len)
 414                                         skiplen = len;
 415                                 packet += skiplen;
 416                                 len -= skiplen;
 417                                 m_pktptr += skiplen;
 418                                 continue;
 419                         } else if (m_pktptr < 4) /* header not complete, thus we don't know if we want this packet */
 420                         {
 421                                 unsigned int storelen = 4 - m_pktptr;
 422                                 if (storelen > len)
 423                                         storelen = len;
 424                                 memcpy(m_pkt + m_pktptr, packet,  storelen);
 425
 426                                 m_pktptr += storelen;
 427                                 len -= storelen;
 428                                 packet += storelen;
 429
 430                                 if (m_pktptr == 4)
 431                                         if (!wantPacket(m_pkt))
 432                                         {
 433                                                         /* skip packet */
 434                                                 packet += 184;
 435                                                 len -= 184;
 436                                                 m_pktptr = 0;
 437                                                 continue;
 438                                         }
 439                         }
 440                                 /* otherwise we complete up to the full packet */
 441                         unsigned int storelen = 188 - m_pktptr;
 442                         if (storelen > len)
 443                                 storelen = len;
 444                         memcpy(m_pkt + m_pktptr, packet,  storelen);
 445                         m_pktptr += storelen;
 446                         len -= storelen;
 447                         packet += storelen;
 448
 449                         if (m_pktptr == 188)
 450                         {
 451                                 m_need_next_packet = processPacket(m_pkt, offset + (packet - packet_start));
 452                                 m_pktptr = 0;
 453                         }
 454                 } else if (len >= 4)  /* if we have a full header... */
 455                 {
 456                         if (wantPacket(packet))  /* decide wheter we need it ... */
 457                         {
 458                                 if (len >= 188)          /* packet complete? */
 459                                 {
 460                                         m_need_next_packet = processPacket(packet, offset + (packet - packet_start)); /* process it now. */
 461                                 } else
 462                                 {
 463                                         memcpy(m_pkt, packet, len);  /* otherwise queue it up */
 464                                         m_pktptr = len;
 465                                 }
 466                         }
 467
 468                                 /* skip packet */
 469                         int sk = len;
 470                         if (sk >= 188)
 471                                 sk = 188;
 472                         else if (!m_pktptr) /* we dont want this packet, otherwise m_pktptr = sk (=len) > 4 */
 473                                 m_pktptr = sk - 188;
 474
 475                         len -= sk;
 476                         packet += sk;
 477                 } else             /* if we don't have a complete header */
 478                 {
 479                         memcpy(m_pkt, packet, len);   /* complete header next time */
 480                         m_pktptr = len;
 481                         packet += len;
 482                         len = 0;
 483                 }
 484         }
 485 }
 486
 487 void eMPEGStreamParserTS::setPid(int _pid)
 488 {
 489         m_pktptr = 0;
 490         m_pid = _pid;
 491 }