parse mpeg4 AVC UADs
[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 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 }