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 eMPEGStreamParserTS::eMPEGStreamParserTS(eMPEGStreamInformation &streaminfo): m_streaminfo(streaminfo), m_pktptr(0), m_pid(-1), m_need_next_packet(0), m_skip(0)
 221 {
 222 }
 223
 224 int eMPEGStreamParserTS::processPacket(const unsigned char *pkt, off_t offset)
 225 {
 226         if (!wantPacket(pkt))
 227                 eWarning("something's wrong.");
 228
 229         const unsigned char *end = pkt + 188;
 230
 231         if (!(pkt[3] & 0x10))
 232         {
 233                 eWarning("[TSPARSE] PUSI set but no payload.");
 234                 return 0;
 235         }
 236
 237         if (pkt[3] & 0x20) // adaption field present?
 238                 pkt += pkt[4] + 4 + 1;  /* skip adaption field and header */
 239         else
 240                 pkt += 4; /* skip header */
 241
 242         if (pkt > end)
 243         {
 244                 eWarning("[TSPARSE] dropping huge adaption field");
 245                 return 0;
 246         }
 247
 248                 // ok, we now have the start of the payload, aligned with the PES packet start.
 249         if (pkt[0] || pkt[1] || (pkt[2] != 1))
 250         {
 251                 eWarning("broken startcode");
 252                 return 0;
 253         }
 254
 255
 256         pts_t pts = 0;
 257         int ptsvalid = 0;
 258
 259         if (pkt[7] & 0x80) // PTS present?
 260         {
 261                 pts  = ((unsigned long long)(pkt[ 9]&0xE))  << 29;
 262                 pts |= ((unsigned long long)(pkt[10]&0xFF)) << 22;
 263                 pts |= ((unsigned long long)(pkt[11]&0xFE)) << 14;
 264                 pts |= ((unsigned long long)(pkt[12]&0xFF)) << 7;
 265                 pts |= ((unsigned long long)(pkt[13]&0xFE)) >> 1;
 266                 ptsvalid = 1;
 267
 268 #if 0
 269                 int sec = pts / 90000;
 270                 int frm = pts % 90000;
 271                 int min = sec / 60;
 272                 sec %= 60;
 273                 int hr = min / 60;
 274                 min %= 60;
 275                 int d = hr / 24;
 276                 hr %= 24;
 277
 278                 eDebug("pts: %016llx %d:%02d:%02d:%02d:%05d", pts, d, hr, min, sec, frm);
 279 #endif
 280         }
 281
 282                 /* advance to payload */
 283         pkt += pkt[8] + 9;
 284
 285                 /* if startcode found */
 286         if (!(pkt[0] || pkt[1] || (pkt[2] != 1)))
 287         {
 288                 if (pkt[3] == 0xb3) /* sequence header */
 289                 {
 290                         if (ptsvalid)
 291                         {
 292                                 m_streaminfo.m_access_points[offset] = pts;
 293                                 eDebug("Sequence header at %llx, pts %llx", offset, pts);
 294                         } else
 295                                 eDebug("Sequence header but no valid PTS value.");
 296                 }
 297         }
 298         return 0;
 299 }
 300
 301 inline int eMPEGStreamParserTS::wantPacket(const unsigned char *hdr) const
 302 {
 303         if (hdr[0] != 0x47)
 304         {
 305                 eDebug("missing sync!");
 306                 return 0;
 307         }
 308         int ppid = ((hdr[1]&0x1F) << 8) | hdr[2];
 309
 310         if (ppid != m_pid)
 311                 return 0;
 312
 313         if (m_need_next_packet)  /* next packet (on this pid) was required? */
 314                 return 1;
 315
 316         if (hdr[1] & 0x40)       /* pusi set: yes. */
 317                 return 1;
 318
 319         return 0;
 320 }
 321
 322 void eMPEGStreamParserTS::parseData(off_t offset, const void *data, unsigned int len)
 323 {
 324         const unsigned char *packet = (const unsigned char*)data;
 325         const unsigned char *packet_start = packet;
 326
 327                         /* sorry for the redundant code here, but there are too many special cases... */
 328         while (len)
 329         {
 330                 if (m_pktptr)
 331                 {
 332                                 /* skip last packet */
 333                         if (m_pktptr < 0)
 334                         {
 335                                 unsigned int skiplen = -m_pktptr;
 336                                 if (skiplen > len)
 337                                         skiplen = len;
 338                                 packet += skiplen;
 339                                 len -= skiplen;
 340                                 m_pktptr += skiplen;
 341                                 continue;
 342                         } else if (m_pktptr < 4) /* header not complete, thus we don't know if we want this packet */
 343                         {
 344                                 unsigned int storelen = 4 - m_pktptr;
 345                                 if (storelen > len)
 346                                         storelen = len;
 347                                 memcpy(m_pkt + m_pktptr, packet,  storelen);
 348
 349                                 m_pktptr += storelen;
 350                                 len -= storelen;
 351                                 packet += storelen;
 352
 353                                 if (m_pktptr == 4)
 354                                         if (!wantPacket(m_pkt))
 355                                         {
 356                                                         /* skip packet */
 357                                                 packet += 184;
 358                                                 len -= 184;
 359                                                 m_pktptr = 0;
 360                                                 continue;
 361                                         }
 362                         }
 363                                 /* otherwise we complete up to the full packet */
 364                         unsigned int storelen = 188 - m_pktptr;
 365                         if (storelen > len)
 366                                 storelen = len;
 367                         memcpy(m_pkt + m_pktptr, packet,  storelen);
 368                         m_pktptr += storelen;
 369                         len -= storelen;
 370                         packet += storelen;
 371
 372                         if (m_pktptr == 188)
 373                         {
 374                                 m_need_next_packet = processPacket(m_pkt, offset + (packet - packet_start));
 375                                 m_pktptr = 0;
 376                         }
 377                 } else if (len >= 4)  /* if we have a full header... */
 378                 {
 379                         if (wantPacket(packet))  /* decide wheter we need it ... */
 380                         {
 381                                 if (len >= 188)          /* packet complete? */
 382                                 {
 383                                         m_need_next_packet = processPacket(packet, offset + (packet - packet_start)); /* process it now. */
 384                                 } else
 385                                 {
 386                                         memcpy(m_pkt, packet, len);  /* otherwise queue it up */
 387                                         m_pktptr = len;
 388                                 }
 389                         }
 390
 391                                 /* skip packet */
 392                         int sk = len;
 393                         if (sk >= 188)
 394                                 sk = 188;
 395                         else if (!m_pktptr) /* we dont want this packet, otherwise m_pktptr = sk (=len) > 4 */
 396                                 m_pktptr = sk - 188;
 397
 398                         len -= sk;
 399                         packet += sk;
 400                 } else             /* if we don't have a complete header */
 401                 {
 402                         memcpy(m_pkt, packet, len);   /* complete header next time */
 403                         m_pktptr = len;
 404                         packet += len;
 405                         len = 0;
 406                 }
 407         }
 408 }
 409
 410 void eMPEGStreamParserTS::setPid(int _pid)
 411 {
 412         m_pktptr = 0;
 413         m_pid = _pid;
 414 }