1 #include <lib/dvb/pvrparse.h>
2 #include <lib/base/eerror.h>
6 #error no byte order defined!
9 eMPEGStreamInformation::eMPEGStreamInformation()
10 : m_structure_cache_valid(0), m_structure_read(0), m_structure_write(0)
14 eMPEGStreamInformation::~eMPEGStreamInformation()
17 fclose(m_structure_read);
18 if (m_structure_write)
19 fclose(m_structure_write);
22 int eMPEGStreamInformation::startSave(const char *filename)
24 m_filename = filename;
25 m_structure_write = fopen((m_filename + ".sc").c_str(), "wb");
29 int eMPEGStreamInformation::stopSave(void)
31 if (m_structure_write)
33 fclose(m_structure_write);
34 m_structure_write = 0;
38 FILE *f = fopen((m_filename + ".ap").c_str(), "wb");
42 for (std::map<off_t, pts_t>::const_iterator i(m_access_points.begin()); i != m_access_points.end(); ++i)
44 unsigned long long d[2];
45 #if BYTE_ORDER == BIG_ENDIAN
49 d[0] = bswap_64(i->first);
50 d[1] = bswap_64(i->second);
52 fwrite(d, sizeof(d), 1, f);
59 int eMPEGStreamInformation::load(const char *filename)
61 m_filename = filename;
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");
68 m_access_points.clear();
69 m_pts_to_offset.clear();
72 unsigned long long d[2];
73 if (fread(d, sizeof(d), 1, f) < 1)
76 #if BYTE_ORDER == LITTLE_ENDIAN
77 d[0] = bswap_64(d[0]);
78 d[1] = bswap_64(d[1]);
80 m_access_points[d[0]] = d[1];
81 m_pts_to_offset.insert(std::pair<pts_t,off_t>(d[1], d[0]));
84 fixupDiscontinuties();
88 bool eMPEGStreamInformation::empty()
90 return m_access_points.empty();
93 void eMPEGStreamInformation::fixupDiscontinuties()
95 m_timestamp_deltas.clear();
96 if (!m_access_points.size())
99 // eDebug("Fixing discontinuities ...");
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))
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 */
108 off_t diff = second->first - first->first;
109 pts_t tdiff = second->second - first->second;
110 tdiff *= first->first;
112 m_timestamp_deltas[0] = first->second - tdiff;
113 // eDebug("first delta is %08llx", first->second - tdiff);
117 if (m_timestamp_deltas.empty())
118 m_timestamp_deltas[m_access_points.begin()->first] = m_access_points.begin()->second;
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)
123 pts_t current = i->second - currentDelta;
124 pts_t diff = current - lastpts_t;
126 if (llabs(diff) > (90000*10)) // 10sec diff
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;
133 lastpts_t = i->second - currentDelta;
137 // eDebug("ok, found %d disconts.", m_timestamp_deltas.size());
140 for (off_t x=0x25807E34ULL; x < 0x25B3CF70; x+= 100000)
144 int r = getPTS(o, p);
145 eDebug("%08llx -> %08llx | %08llx, %d, %08llx %08llx", x, getDelta(x), getInterpolated(x), r, o, p);
150 pts_t eMPEGStreamInformation::getDelta(off_t offset)
152 if (!m_timestamp_deltas.size())
154 std::map<off_t,pts_t>::iterator i = m_timestamp_deltas.upper_bound(offset);
156 /* i can be the first when you query for something before the first PTS */
157 if (i != m_timestamp_deltas.begin())
163 int eMPEGStreamInformation::fixupPTS(const off_t &offset, pts_t &ts)
165 if (!m_timestamp_deltas.size())
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();
175 if ((nearest == m_pts_to_offset.end()) || (llabs(l->first - ts) < llabs(nearest->first - ts)))
179 if (nearest == m_pts_to_offset.end())
182 ts -= getDelta(nearest->second);
187 int eMPEGStreamInformation::getPTS(off_t &offset, pts_t &pts)
189 std::map<off_t,pts_t>::iterator before = m_access_points.lower_bound(offset);
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())
195 if (before == m_access_points.end())
201 offset = before->first;
202 pts = before->second - getDelta(offset);
207 pts_t eMPEGStreamInformation::getInterpolated(off_t offset)
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);
214 if (before != m_access_points.begin())
216 else /* we query before the first known timestamp ... FIXME */
220 if (before == m_access_points.end())
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);
227 pts_t before_ts = before->second - getDelta(before->first);
228 pts_t after_ts = after->second - getDelta(after->first);
230 // eDebug("%08llx .. ? .. %08llx", before_ts, after_ts);
231 // eDebug("%08llx .. %08llx .. %08llx", before->first, offset, after->first);
233 pts_t diff = after_ts - before_ts;
234 off_t diff_off = after->first - before->first;
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;
241 off_t eMPEGStreamInformation::getAccessPoint(pts_t ts, int marg)
243 /* FIXME: more efficient implementation */
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)
250 pts_t delta = getDelta(i->first);
251 pts_t c = i->second - delta;
254 return (last + i->first)/376*188;
256 return (last + last2)/376*188;
265 return (last + last2)/376*188;
270 int eMPEGStreamInformation::getNextAccessPoint(pts_t &ts, const pts_t &start, int direction)
272 off_t offset = getAccessPoint(start);
274 std::map<off_t, pts_t>::const_iterator i = m_access_points.find(offset);
275 if (i == m_access_points.end())
277 eDebug("getNextAccessPoint: initial AP not found");
280 c1 = i->second - getDelta(i->first);
285 if (i == m_access_points.end())
288 c2 = i->second - getDelta(i->first);
289 if (c1 == c2) { // Discontinuity
291 c2 = i->second - getDelta(i->first);
298 if (i == m_access_points.begin())
304 c2 = i->second - getDelta(i->first);
305 if (c1 == c2) { // Discontinuity
307 c2 = i->second - getDelta(i->first);
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));
319 void eMPEGStreamInformation::writeStructureEntry(off_t offset, structure_data data)
321 unsigned long long d[2];
322 #if BYTE_ORDER == BIG_ENDIAN
326 d[0] = bswap_64(offset);
327 d[1] = bswap_64(data);
329 if (m_structure_write)
330 fwrite(d, sizeof(d), 1, m_structure_write);
333 int eMPEGStreamInformation::getStructureEntry(off_t &offset, unsigned long long &data, int get_next)
335 if (!m_structure_read)
337 eDebug("getStructureEntry failed because of no m_structure_read");
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))
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;
349 /* do a binary search */
350 int count = l / entry_size;
355 int step = count >> 1;
357 fseek(m_structure_read, (i + step) * entry_size, SEEK_SET);
358 if (!fread(d, 1, entry_size, m_structure_read))
360 eDebug("read error at entry %d", i);
364 #if BYTE_ORDER != BIG_ENDIAN
365 d[0] = bswap_64(d[0]);
366 d[1] = bswap_64(d[1]);
368 // eDebug("%d: %08llx > %llx", i, d[0], d[1]);
370 if (d[0] < (unsigned long long)offset)
378 eDebug("found %d", i);
380 /* put that in the middle */
381 i -= struture_cache_entries / 2;
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)
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]);
398 m_structure_cache[i * 2] = 0x7fffffffffffffffULL; /* fill with harmless content */
399 m_structure_cache[i * 2 + 1] = 0;
402 m_structure_cache_valid = 1;
406 while ((off_t)m_structure_cache[i * 2] <= offset)
409 if (i == struture_cache_entries)
411 eDebug("structure data consistency fail!, we are looking for %llx, but last entry is %llx", offset, m_structure_cache[i*2-2]);
417 eDebug("structure data (first entry) consistency fail!");
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];
430 int eMPEGStreamInformation::getStructureEntry_next(off_t &offset, unsigned long long &data)
432 if (!m_structure_read)
434 eDebug("getStructureEntry failed because of no m_structure_read");
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))
442 if(update_structure_cache_entries(_offset))
449 while ((off_t)m_structure_cache[i * 2] <= offset)
452 if (i == struture_cache_entries)
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]);
460 eDebug("structure data (first entry) consistency fail!");
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];
470 int eMPEGStreamInformation::getStructureEntry_prev(off_t &offset, unsigned long long &data)
472 if (!m_structure_read)
474 eDebug("getStructureEntry failed because of no m_structure_read");
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))
482 if(update_structure_cache_entries(_offset))
488 int i = struture_cache_entries-1;
489 while ((off_t)m_structure_cache[i * 2] >= offset)
493 eDebug("structure data consistency fail!, we are looking for %llu, but last entry is %llu", offset, m_structure_cache[i * 2]);
498 if (i == struture_cache_entries-1)
500 eDebug("structure data (first entry) consistency fail!");
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];
510 int eMPEGStreamInformation::update_structure_cache_entries(off_t offset)
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;
518 /* do a binary search */
519 int count = l / entry_size;
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))
528 eDebug("read error at entry %d", i);
531 #if BYTE_ORDER != BIG_ENDIAN
532 d[0] = bswap_64(d[0]);
533 d[1] = bswap_64(d[1]);
535 // eDebug("%d: %08llx > %llx", i, d[0], d[1]);
536 if (d[0] < (unsigned long long)offset)
543 eDebug("found %d", i);
545 /* put that in the middle */
546 i -= struture_cache_entries / 2;
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)
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]);
563 m_structure_cache[i * 2] = 0x7fffffffffffffffULL; /* fill with harmless content */
564 m_structure_cache[i * 2 + 1] = 0x7fffffffffffffffULL;
567 m_structure_cache_valid = 1;
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)
575 int eMPEGStreamParserTS::processPacket(const unsigned char *pkt, off_t offset)
577 if (!wantPacket(pkt))
578 eWarning("something's wrong.");
580 const unsigned char *end = pkt + 188, *begin = pkt;
582 int pusi = !!(pkt[1] & 0x40);
584 if (!(pkt[3] & 0x10)) /* no payload? */
587 if (pkt[3] & 0x20) // adaptation field present?
588 pkt += pkt[4] + 4 + 1; /* skip adaptation field and header */
590 pkt += 4; /* skip header */
594 eWarning("[TSPARSE] dropping huge adaption field");
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))
606 eWarning("broken startcode");
610 if (pkt[7] & 0x80) // PTS present?
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;
620 m_last_pts_valid = 1;
623 int sec = pts / 90000;
624 int frm = pts % 90000;
632 eDebug("pts: %016llx %d:%02d:%02d:%02d:%05d", pts, d, hr, min, sec, frm);
636 /* advance to payload */
640 while (pkt < (end-4))
642 int pkt_offset = pkt - begin;
643 if (!(pkt[0] || pkt[1] || (pkt[2] != 1)))
645 // eDebug("SC %02x %02x %02x %02x, %02x", pkt[0], pkt[1], pkt[2], pkt[3], pkt[4]);
648 if (m_streamtype == 0) /* mpeg2 */
650 if ((sc == 0x00) || (sc == 0xb3) || (sc == 0xb8)) /* picture, sequence, group start code */
652 unsigned long long data = sc | (pkt[4] << 8) | (pkt[5] << 16) | (pkt[6] << 24);
653 m_streaminfo.writeStructureEntry(offset + pkt_offset, data & 0xFFFFFFFFULL);
655 if (pkt[3] == 0xb3) /* sequence header */
659 m_streaminfo.m_access_points[offset] = pts;
660 // eDebug("Sequence header at %llx, pts %llx", offset, pts);
662 /*eDebug("Sequence header but no valid PTS value.")*/;
666 if (m_streamtype == 1) /* H.264 */
670 /* store image type */
671 unsigned long long data = sc | (pkt[4] << 8);
672 m_streaminfo.writeStructureEntry(offset + pkt_offset, data);
674 if (pkt[3] == 0x09 && /* MPEG4 AVC NAL unit access delimiter */
675 (pkt[4] >> 5) == 0) /* and I-frame */
679 m_streaminfo.m_access_points[offset] = pts;
680 // eDebug("MPEG4 AVC UAD at %llx, pts %llx", offset, pts);
682 /*eDebug("MPEG4 AVC UAD but no valid PTS value.")*/;
691 inline int eMPEGStreamParserTS::wantPacket(const unsigned char *hdr) const
695 eDebug("missing sync!");
698 int ppid = ((hdr[1]&0x1F) << 8) | hdr[2];
703 if (m_need_next_packet) /* next packet (on this pid) was required? */
706 if (hdr[1] & 0x40) /* pusi set: yes. */
709 return m_streamtype == 0; /* we need all packets for MPEG2, but only PUSI packets for H.264 */
712 void eMPEGStreamParserTS::parseData(off_t offset, const void *data, unsigned int len)
714 const unsigned char *packet = (const unsigned char*)data;
715 const unsigned char *packet_start = packet;
717 /* sorry for the redundant code here, but there are too many special cases... */
720 /* emergency resync. usually, this should not happen, because the data should
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.
726 if this is a false 0x47, the packet will be dropped by wantPacket, and the
727 next time, sync will be re-established. */
729 while (!m_pktptr && len)
731 if (packet[0] == 0x47)
739 eDebug("SYNC LOST: skipped %d bytes.", skipped);
746 /* skip last packet */
749 unsigned int skiplen = -m_pktptr;
756 } else if (m_pktptr < 4) /* header not complete, thus we don't know if we want this packet */
758 unsigned int storelen = 4 - m_pktptr;
761 memcpy(m_pkt + m_pktptr, packet, storelen);
763 m_pktptr += storelen;
768 if (!wantPacket(m_pkt))
777 /* otherwise we complete up to the full packet */
778 unsigned int storelen = 188 - m_pktptr;
781 memcpy(m_pkt + m_pktptr, packet, storelen);
782 m_pktptr += storelen;
788 m_need_next_packet = processPacket(m_pkt, offset + (packet - packet_start));
791 } else if (len >= 4) /* if we have a full header... */
793 if (wantPacket(packet)) /* decide wheter we need it ... */
795 if (len >= 188) /* packet complete? */
797 m_need_next_packet = processPacket(packet, offset + (packet - packet_start)); /* process it now. */
800 memcpy(m_pkt, packet, len); /* otherwise queue it up */
809 else if (!m_pktptr) /* we dont want this packet, otherwise m_pktptr = sk (=len) > 4 */
814 } else /* if we don't have a complete header */
816 memcpy(m_pkt, packet, len); /* complete header next time */
824 void eMPEGStreamParserTS::setPid(int _pid, int type)
831 int eMPEGStreamParserTS::getLastPTS(pts_t &last_pts)
833 if (!m_last_pts_valid)
838 last_pts = m_last_pts;