Merge branch 'bug_202_networkconfig_cleanup'
[enigma2.git] / 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*5)) // 5sec 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 %llx, found %llx=%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 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)
431 {
432 }
433
434 int eMPEGStreamParserTS::processPacket(const unsigned char *pkt, off_t offset)
435 {
436         if (!wantPacket(pkt))
437                 eWarning("something's wrong.");
438
439         const unsigned char *end = pkt + 188, *begin = pkt;
440         
441         int pusi = !!(pkt[1] & 0x40);
442         
443         if (!(pkt[3] & 0x10)) /* no payload? */
444                 return 0;
445
446         if (pkt[3] & 0x20) // adaptation field present?
447                 pkt += pkt[4] + 4 + 1;  /* skip adaptation field and header */
448         else
449                 pkt += 4; /* skip header */
450
451         if (pkt > end)
452         {
453                 eWarning("[TSPARSE] dropping huge adaption field");
454                 return 0;
455         }
456
457         pts_t pts = 0;
458         int ptsvalid = 0;
459         
460         if (pusi)
461         {
462                         // ok, we now have the start of the payload, aligned with the PES packet start.
463                 if (pkt[0] || pkt[1] || (pkt[2] != 1))
464                 {
465                         eWarning("broken startcode");
466                         return 0;
467                 }
468
469                 if (pkt[7] & 0x80) // PTS present?
470                 {
471                         pts  = ((unsigned long long)(pkt[ 9]&0xE))  << 29;
472                         pts |= ((unsigned long long)(pkt[10]&0xFF)) << 22;
473                         pts |= ((unsigned long long)(pkt[11]&0xFE)) << 14;
474                         pts |= ((unsigned long long)(pkt[12]&0xFF)) << 7;
475                         pts |= ((unsigned long long)(pkt[13]&0xFE)) >> 1;
476                         ptsvalid = 1;
477                         
478                         m_last_pts = pts;
479                         m_last_pts_valid = 1;
480
481         #if 0           
482                         int sec = pts / 90000;
483                         int frm = pts % 90000;
484                         int min = sec / 60;
485                         sec %= 60;
486                         int hr = min / 60;
487                         min %= 60;
488                         int d = hr / 24;
489                         hr %= 24;
490                         
491                         eDebug("pts: %016llx %d:%02d:%02d:%02d:%05d", pts, d, hr, min, sec, frm);
492         #endif
493                 }
494                 
495                         /* advance to payload */
496                 pkt += pkt[8] + 9;
497         }
498
499         while (pkt < (end-4))
500         {
501                 int pkt_offset = pkt - begin;
502                 if (!(pkt[0] || pkt[1] || (pkt[2] != 1)))
503                 {
504 //                      eDebug("SC %02x %02x %02x %02x, %02x", pkt[0], pkt[1], pkt[2], pkt[3], pkt[4]);
505                         int sc = pkt[3];
506                         
507                         if (m_streamtype == 0) /* mpeg2 */
508                         {
509                                 if ((sc == 0x00) || (sc == 0xb3) || (sc == 0xb8)) /* picture, sequence, group start code */
510                                 {
511                                         unsigned long long data = sc | (pkt[4] << 8) | (pkt[5] << 16) | (pkt[6] << 24);
512                                         m_streaminfo.writeStructureEntry(offset + pkt_offset, data  & 0xFFFFFFFFULL);
513                                 }
514                                 if (pkt[3] == 0xb3) /* sequence header */
515                                 {
516                                         if (ptsvalid)
517                                         {
518                                                 m_streaminfo.m_access_points[offset] = pts;
519         //                                      eDebug("Sequence header at %llx, pts %llx", offset, pts);
520                                         } else
521                                                 /*eDebug("Sequence header but no valid PTS value.")*/;
522                                 }
523                         }
524
525                         if (m_streamtype == 1) /* H.264 */
526                         {
527                                 if (sc == 0x09)
528                                 {
529                                                 /* store image type */
530                                         unsigned long long data = sc | (pkt[4] << 8);
531                                         m_streaminfo.writeStructureEntry(offset + pkt_offset, data);
532                                 }
533                                 if (pkt[3] == 0x09 &&   /* MPEG4 AVC NAL unit access delimiter */
534                                          (pkt[4] >> 5) == 0) /* and I-frame */
535                                 {
536                                         if (ptsvalid)
537                                         {
538                                                 m_streaminfo.m_access_points[offset] = pts;
539         //                              eDebug("MPEG4 AVC UAD at %llx, pts %llx", offset, pts);
540                                         } else
541                                                 /*eDebug("MPEG4 AVC UAD but no valid PTS value.")*/;
542                                 }
543                         }
544                 }
545                 ++pkt;
546         }
547         return 0;
548 }
549
550 inline int eMPEGStreamParserTS::wantPacket(const unsigned char *hdr) const
551 {
552         if (hdr[0] != 0x47)
553         {
554                 eDebug("missing sync!");
555                 return 0;
556         }
557         int ppid = ((hdr[1]&0x1F) << 8) | hdr[2];
558
559         if (ppid != m_pid)
560                 return 0;
561                 
562         if (m_need_next_packet)  /* next packet (on this pid) was required? */
563                 return 1;
564         
565         if (hdr[1] & 0x40)       /* pusi set: yes. */
566                 return 1;
567
568         return m_streamtype == 0; /* we need all packets for MPEG2, but only PUSI packets for H.264 */
569 }
570
571 void eMPEGStreamParserTS::parseData(off_t offset, const void *data, unsigned int len)
572 {
573         const unsigned char *packet = (const unsigned char*)data;
574         const unsigned char *packet_start = packet;
575         
576                         /* sorry for the redundant code here, but there are too many special cases... */
577         while (len)
578         {
579                         /* emergency resync. usually, this should not happen, because the data should 
580                            be sync-aligned.
581                            
582                            to make this code work for non-strictly-sync-aligned data, (for example, bad 
583                            files) we fix a possible resync here by skipping data until the next 0x47.
584                            
585                            if this is a false 0x47, the packet will be dropped by wantPacket, and the
586                            next time, sync will be re-established. */
587                 int skipped = 0;
588                 while (!m_pktptr && len)
589                 {
590                         if (packet[0] == 0x47)
591                                 break;
592                         len--;
593                         packet++;
594                         skipped++;
595                 }
596                 
597                 if (skipped)
598                         eDebug("SYNC LOST: skipped %d bytes.", skipped);
599                 
600                 if (!len)
601                         break;
602                 
603                 if (m_pktptr)
604                 {
605                                 /* skip last packet */
606                         if (m_pktptr < 0)
607                         {
608                                 unsigned int skiplen = -m_pktptr;
609                                 if (skiplen > len)
610                                         skiplen = len;
611                                 packet += skiplen;
612                                 len -= skiplen;
613                                 m_pktptr += skiplen;
614                                 continue;
615                         } else if (m_pktptr < 4) /* header not complete, thus we don't know if we want this packet */
616                         {
617                                 unsigned int storelen = 4 - m_pktptr;
618                                 if (storelen > len)
619                                         storelen = len;
620                                 memcpy(m_pkt + m_pktptr, packet,  storelen);
621                                 
622                                 m_pktptr += storelen;
623                                 len -= storelen;
624                                 packet += storelen;
625                                 
626                                 if (m_pktptr == 4)
627                                         if (!wantPacket(m_pkt))
628                                         {
629                                                         /* skip packet */
630                                                 packet += 184;
631                                                 len -= 184;
632                                                 m_pktptr = 0;
633                                                 continue;
634                                         }
635                         }
636                                 /* otherwise we complete up to the full packet */
637                         unsigned int storelen = 188 - m_pktptr;
638                         if (storelen > len)
639                                 storelen = len;
640                         memcpy(m_pkt + m_pktptr, packet,  storelen);
641                         m_pktptr += storelen;
642                         len -= storelen;
643                         packet += storelen;
644                         
645                         if (m_pktptr == 188)
646                         {
647                                 m_need_next_packet = processPacket(m_pkt, offset + (packet - packet_start));
648                                 m_pktptr = 0;
649                         }
650                 } else if (len >= 4)  /* if we have a full header... */
651                 {
652                         if (wantPacket(packet))  /* decide wheter we need it ... */
653                         {
654                                 if (len >= 188)          /* packet complete? */
655                                 {
656                                         m_need_next_packet = processPacket(packet, offset + (packet - packet_start)); /* process it now. */
657                                 } else
658                                 {
659                                         memcpy(m_pkt, packet, len);  /* otherwise queue it up */
660                                         m_pktptr = len;
661                                 }
662                         }
663
664                                 /* skip packet */
665                         int sk = len;
666                         if (sk >= 188)
667                                 sk = 188;
668                         else if (!m_pktptr) /* we dont want this packet, otherwise m_pktptr = sk (=len) > 4 */
669                                 m_pktptr = sk - 188;
670
671                         len -= sk;
672                         packet += sk;
673                 } else             /* if we don't have a complete header */
674                 {
675                         memcpy(m_pkt, packet, len);   /* complete header next time */
676                         m_pktptr = len;
677                         packet += len;
678                         len = 0;
679                 }
680         }
681 }
682
683 void eMPEGStreamParserTS::setPid(int _pid, int type)
684 {
685         m_pktptr = 0;
686         m_pid = _pid;
687         m_streamtype = type;
688 }
689
690 int eMPEGStreamParserTS::getLastPTS(pts_t &last_pts)
691 {
692         if (!m_last_pts_valid)
693         {
694                 last_pts = 0;
695                 return -1;
696         }
697         last_pts = m_last_pts;
698         return 0;
699 }
700