lib/dvb/tstools.cpp

   1 #define _ISOC99_SOURCE /* for llabs */
   2 #include <lib/dvb/tstools.h>
   3 #include <lib/base/eerror.h>
   4 #include <unistd.h>
   5 #include <fcntl.h>
   6
   7 #include <stdio.h>
   8
   9 eDVBTSTools::eDVBTSTools()
  10 {
  11         m_pid = -1;
  12         m_maxrange = 256*1024;
  13
  14         m_begin_valid = 0;
  15         m_end_valid = 0;
  16
  17         m_use_streaminfo = 0;
  18         m_samples_taken = 0;
  19
  20         m_last_filelength = 0;
  21
  22         m_futile = 0;
  23 }
  24
  25 eDVBTSTools::~eDVBTSTools()
  26 {
  27         closeFile();
  28 }
  29
  30 int eDVBTSTools::openFile(const char *filename, int nostreaminfo)
  31 {
  32         closeFile();
  33
  34         if (!nostreaminfo)
  35                 m_streaminfo.load((std::string(filename) + ".ap").c_str());
  36
  37         if (!m_streaminfo.empty())
  38                 m_use_streaminfo = 1;
  39         else
  40         {
  41 //              eDebug("no recorded stream information available");
  42                 m_use_streaminfo = 0;
  43         }
  44
  45         m_samples_taken = 0;
  46
  47         if (m_file.open(filename, 1) < 0)
  48                 return -1;
  49         return 0;
  50 }
  51
  52 void eDVBTSTools::closeFile()
  53 {
  54         m_file.close();
  55 }
  56
  57 void eDVBTSTools::setSyncPID(int pid)
  58 {
  59         m_pid = pid;
  60 }
  61
  62 void eDVBTSTools::setSearchRange(int maxrange)
  63 {
  64         m_maxrange = maxrange;
  65 }
  66
  67         /* getPTS extracts a pts value from any PID at a given offset. */
  68 int eDVBTSTools::getPTS(off_t &offset, pts_t &pts, int fixed)
  69 {
  70         if (m_use_streaminfo)
  71                 return m_streaminfo.getPTS(offset, pts);
  72
  73         if (!m_file.valid())
  74                 return -1;
  75
  76         offset -= offset % 188;
  77
  78         if (m_file.lseek(offset, SEEK_SET) < 0)
  79         {
  80                 eDebug("lseek failed");
  81                 return -1;
  82         }
  83
  84         int left = m_maxrange;
  85
  86         while (left >= 188)
  87         {
  88                 unsigned char packet[188];
  89                 if (m_file.read(packet, 188) != 188)
  90                 {
  91                         eDebug("read error");
  92                         break;
  93                 }
  94                 left -= 188;
  95                 offset += 188;
  96
  97                 if (packet[0] != 0x47)
  98                 {
  99                         eDebug("resync");
 100                         int i = 0;
 101                         while (i < 188)
 102                         {
 103                                 if (packet[i] == 0x47)
 104                                         break;
 105                                 ++i;
 106                         }
 107                         offset = m_file.lseek(i - 188, SEEK_CUR);
 108                         continue;
 109                 }
 110
 111                 int pid = ((packet[1] << 8) | packet[2]) & 0x1FFF;
 112                 int pusi = !!(packet[1] & 0x40);
 113
 114 //              printf("PID %04x, PUSI %d\n", pid, pusi);
 115
 116                 unsigned char *payload;
 117
 118                         /* check for adaption field */
 119                 if (packet[3] & 0x20)
 120                 {
 121                         if (packet[4] >= 183)
 122                                 continue;
 123                         if (packet[4])
 124                         {
 125                                 if (packet[5] & 0x10) /* PCR present */
 126                                 {
 127                                         pts  = ((unsigned long long)(packet[ 6]&0xFF)) << 25;
 128                                         pts |= ((unsigned long long)(packet[ 7]&0xFF)) << 17;
 129                                         pts |= ((unsigned long long)(packet[ 8]&0xFE)) << 9;
 130                                         pts |= ((unsigned long long)(packet[ 9]&0xFF)) << 1;
 131                                         pts |= ((unsigned long long)(packet[10]&0x80)) >> 7;
 132                                         offset -= 188;
 133                                         eDebug("PCR  found at %llx: %16llx", offset, pts);
 134                                         if (fixed && fixupPTS(offset, pts))
 135                                                 return -1;
 136                                         return 0;
 137                                 }
 138                         }
 139                         payload = packet + packet[4] + 4 + 1;
 140                 } else
 141                         payload = packet + 4;
 142
 143
 144                 if (m_pid >= 0)
 145                         if (pid != m_pid)
 146                                 continue;
 147                 if (!pusi)
 148                         continue;
 149
 150
 151                         /* somehow not a startcode. (this is invalid, since pusi was set.) ignore it. */
 152                 if (payload[0] || payload[1] || (payload[2] != 1))
 153                         continue;
 154
 155                         /* drop non-audio, non-video packets because other streams
 156                            can be non-compliant.*/
 157                 if (((payload[3] & 0xE0) != 0xC0) &&  // audio
 158                     ((payload[3] & 0xF0) != 0xE0))    // video
 159                         continue;
 160
 161                 if (payload[7] & 0x80) /* PTS */
 162                 {
 163                         pts  = ((unsigned long long)(payload[ 9]&0xE))  << 29;
 164                         pts |= ((unsigned long long)(payload[10]&0xFF)) << 22;
 165                         pts |= ((unsigned long long)(payload[11]&0xFE)) << 14;
 166                         pts |= ((unsigned long long)(payload[12]&0xFF)) << 7;
 167                         pts |= ((unsigned long long)(payload[13]&0xFE)) >> 1;
 168                         offset -= 188;
 169
 170 //                      eDebug("found pts %08llx at %08llx pid %02x stream: %02x", pts, offset, pid, payload[3]);
 171
 172                                 /* convert to zero-based */
 173                         if (fixed && fixupPTS(offset, pts))
 174                                         return -1;
 175                         return 0;
 176                 }
 177         }
 178
 179         return -1;
 180 }
 181
 182 int eDVBTSTools::fixupPTS(const off_t &offset, pts_t &now)
 183 {
 184         if (m_use_streaminfo)
 185         {
 186                 return m_streaminfo.fixupPTS(offset, now);
 187         } else
 188         {
 189                         /* for the simple case, we assume one epoch, with up to one wrap around in the middle. */
 190                 calcBegin();
 191                 if (!m_begin_valid)
 192                 {
 193                         eDebug("begin not valid, can't fixup");
 194                         return -1;
 195                 }
 196
 197                 pts_t pos = m_pts_begin;
 198                 if ((now < pos) && ((pos - now) < 90000 * 10))
 199                 {
 200                         pos = 0;
 201                         return 0;
 202                 }
 203
 204                 if (now < pos) /* wrap around */
 205                         now = now + 0x200000000LL - pos;
 206                 else
 207                         now -= pos;
 208                 return 0;
 209         }
 210 }
 211
 212 int eDVBTSTools::getOffset(off_t &offset, pts_t &pts)
 213 {
 214         if (m_use_streaminfo)
 215         {
 216                 offset = m_streaminfo.getAccessPoint(pts);
 217                 return 0;
 218         } else
 219         {
 220                 calcBegin(); calcEnd();
 221
 222                 if (!m_begin_valid)
 223                         return -1;
 224                 if (!m_end_valid)
 225                         return -1;
 226
 227                 if (!m_samples_taken)
 228                         takeSamples();
 229
 230                 if (!m_samples.empty())
 231                 {
 232                         int maxtries = 5;
 233                         pts_t p = -1;
 234
 235                         while (maxtries--)
 236                         {
 237                                         /* search entry before and after */
 238                                 std::map<pts_t, off_t>::const_iterator l = m_samples.lower_bound(pts);
 239                                 std::map<pts_t, off_t>::const_iterator u = l;
 240
 241                                 if (l != m_samples.begin())
 242                                         --l;
 243
 244                                         /* we could have seeked beyond the end */
 245                                 if (u == m_samples.end())
 246                                 {
 247                                                 /* use last segment for interpolation. */
 248                                         if (l != m_samples.begin())
 249                                         {
 250                                                 --u;
 251                                                 --l;
 252                                         }
 253                                 }
 254
 255                                         /* if we don't have enough points */
 256                                 if (u == m_samples.end())
 257                                         break;
 258
 259                                 pts_t pts_diff = u->first - l->first;
 260                                 off_t offset_diff = u->second - l->second;
 261
 262                                 if (offset_diff < 0)
 263                                 {
 264                                         eDebug("something went wrong when taking samples.");
 265                                         m_samples.clear();
 266                                         takeSamples();
 267                                         continue;
 268                                 }
 269
 270                                 eDebug("using: %llx:%llx -> %llx:%llx", l->first, u->first, l->second, u->second);
 271
 272                                 int bitrate;
 273
 274                                 if (pts_diff)
 275                                         bitrate = offset_diff * 90000 * 8 / pts_diff;
 276                                 else
 277                                         bitrate = 0;
 278
 279                                 offset = l->second;
 280                                 offset += ((pts - l->first) * (pts_t)bitrate) / 8ULL / 90000ULL;
 281                                 offset -= offset % 188;
 282
 283                                 p = pts;
 284
 285                                 if (!takeSample(offset, p))
 286                                 {
 287                                         int diff = (p - pts) / 90;
 288
 289                                         eDebug("calculated diff %d ms", diff);
 290                                         if (abs(diff) > 300)
 291                                         {
 292                                                 eDebug("diff to big, refining");
 293                                                 continue;
 294                                         }
 295                                 } else
 296                                         eDebug("no sample taken, refinement not possible.");
 297
 298                                 break;
 299                         }
 300
 301                                 /* if even the first sample couldn't be taken, fall back. */
 302                                 /* otherwise, return most refined result. */
 303                         if (p != -1)
 304                         {
 305                                 pts = p;
 306                                 eDebug("aborting. Taking %llx as offset for %lld", offset, pts);
 307                                 return 0;
 308                         }
 309                 }
 310
 311                 int bitrate = calcBitrate();
 312                 offset = pts * (pts_t)bitrate / 8ULL / 90000ULL;
 313                 eDebug("fallback, bitrate=%d, results in %016llx", bitrate, offset);
 314                 offset -= offset % 188;
 315
 316                 return 0;
 317         }
 318 }
 319
 320 int eDVBTSTools::getNextAccessPoint(pts_t &ts, const pts_t &start, int direction)
 321 {
 322         if (m_use_streaminfo)
 323                 return m_streaminfo.getNextAccessPoint(ts, start, direction);
 324         else
 325         {
 326                 eDebug("can't get next access point without streaminfo");
 327                 return -1;
 328         }
 329 }
 330
 331 void eDVBTSTools::calcBegin()
 332 {
 333         if (!m_file.valid())
 334                 return;
 335
 336         if (!(m_begin_valid || m_futile))
 337         {
 338                 m_offset_begin = 0;
 339                 if (!getPTS(m_offset_begin, m_pts_begin))
 340                         m_begin_valid = 1;
 341                 else
 342                         m_futile = 1;
 343         }
 344 }
 345
 346 void eDVBTSTools::calcEnd()
 347 {
 348         if (!m_file.valid())
 349                 return;
 350
 351         off_t end = m_file.lseek(0, SEEK_END);
 352
 353         if (llabs(end - m_last_filelength) > 1*1024*1024)
 354         {
 355                 m_last_filelength = end;
 356                 m_end_valid = 0;
 357
 358                 m_futile = 0;
 359 //              eDebug("file size changed, recalc length");
 360         }
 361
 362         int maxiter = 10;
 363
 364         m_offset_end = m_last_filelength;
 365
 366         while (!(m_end_valid || m_futile))
 367         {
 368                 if (!--maxiter)
 369                 {
 370                         m_futile = 1;
 371                         return;
 372                 }
 373
 374                 m_offset_end -= m_maxrange;
 375                 if (m_offset_end < 0)
 376                         m_offset_end = 0;
 377
 378                         /* restore offset if getpts fails */
 379                 off_t off = m_offset_end;
 380
 381                 if (!getPTS(m_offset_end, m_pts_end))
 382                         m_end_valid = 1;
 383                 else
 384                         m_offset_end = off;
 385
 386                 if (!m_offset_end)
 387                 {
 388                         m_futile = 1;
 389                         break;
 390                 }
 391         }
 392 }
 393
 394 int eDVBTSTools::calcLen(pts_t &len)
 395 {
 396         calcBegin(); calcEnd();
 397         if (!(m_begin_valid && m_end_valid))
 398                 return -1;
 399         len = m_pts_end - m_pts_begin;
 400                 /* wrap around? */
 401         if (len < 0)
 402                 len += 0x200000000LL;
 403         return 0;
 404 }
 405
 406 int eDVBTSTools::calcBitrate()
 407 {
 408         calcBegin(); calcEnd();
 409         if (!(m_begin_valid && m_end_valid))
 410                 return -1;
 411
 412         pts_t len_in_pts = m_pts_end - m_pts_begin;
 413
 414                 /* wrap around? */
 415         if (len_in_pts < 0)
 416                 len_in_pts += 0x200000000LL;
 417         off_t len_in_bytes = m_offset_end - m_offset_begin;
 418
 419         if (!len_in_pts)
 420                 return -1;
 421
 422         unsigned long long bitrate = len_in_bytes * 90000 * 8 / len_in_pts;
 423         if ((bitrate < 10000) || (bitrate > 100000000))
 424                 return -1;
 425
 426         return bitrate;
 427 }
 428
 429         /* pts, off */
 430 void eDVBTSTools::takeSamples()
 431 {
 432         m_samples_taken = 1;
 433         m_samples.clear();
 434         pts_t dummy;
 435         if (calcLen(dummy) == -1)
 436                 return;
 437
 438         int nr_samples = 30;
 439         off_t bytes_per_sample = (m_offset_end - m_offset_begin) / (long long)nr_samples;
 440         if (bytes_per_sample < 40*1024*1024)
 441                 bytes_per_sample = 40*1024*1024;
 442
 443         bytes_per_sample -= bytes_per_sample % 188;
 444
 445         for (off_t offset = m_offset_begin; offset < m_offset_end; offset += bytes_per_sample)
 446         {
 447                 pts_t p;
 448                 takeSample(offset, p);
 449         }
 450         m_samples[0] = m_offset_begin;
 451         m_samples[m_pts_end - m_pts_begin] = m_offset_end;
 452
 453 //      eDebug("begin, end: %llx %llx", m_offset_begin, m_offset_end);
 454 }
 455
 456         /* returns 0 when a sample was taken. */
 457 int eDVBTSTools::takeSample(off_t off, pts_t &p)
 458 {
 459         if (!eDVBTSTools::getPTS(off, p, 1))
 460         {
 461                         /* as we are happily mixing PTS and PCR values (no comment, please), we might
 462                            end up with some "negative" segments.
 463
 464                            so check if this new sample is between the previous and the next field*/
 465
 466                 std::map<pts_t, off_t>::const_iterator l = m_samples.lower_bound(p);
 467                 std::map<pts_t, off_t>::const_iterator u = l;
 468
 469                 if (l != m_samples.begin())
 470                 {
 471                         --l;
 472                         if (u != m_samples.end())
 473                         {
 474                                 if ((l->second > off) || (u->second < off))
 475                                 {
 476                                         eDebug("ignoring sample %llx %llx %llx (%lld %lld %lld)",
 477                                                 l->second, off, u->second, l->first, p, u->first);
 478                                         return 1;
 479                                 }
 480                         }
 481                 }
 482
 483
 484                 m_samples[p] = off;
 485                 return 0;
 486         }
 487         return 1;
 488 }
 489
 490 int eDVBTSTools::findPMT(int &pmt_pid, int &service_id)
 491 {
 492                 /* FIXME: this will be factored out soon! */
 493         if (!m_file.valid())
 494         {
 495                 eDebug(" file not valid");
 496                 return -1;
 497         }
 498
 499         if (m_file.lseek(0, SEEK_SET) < 0)
 500         {
 501                 eDebug("seek failed");
 502                 return -1;
 503         }
 504
 505         int left = 5*1024*1024;
 506
 507         while (left >= 188)
 508         {
 509                 unsigned char packet[188];
 510                 if (m_file.read(packet, 188) != 188)
 511                 {
 512                         eDebug("read error");
 513                         break;
 514                 }
 515                 left -= 188;
 516
 517                 if (packet[0] != 0x47)
 518                 {
 519                         int i = 0;
 520                         while (i < 188)
 521                         {
 522                                 if (packet[i] == 0x47)
 523                                         break;
 524                                 ++i;
 525                         }
 526                         m_file.lseek(i - 188, SEEK_CUR);
 527                         continue;
 528                 }
 529
 530                 int pid = ((packet[1] << 8) | packet[2]) & 0x1FFF;
 531
 532                 int pusi = !!(packet[1] & 0x40);
 533
 534                 if (!pusi)
 535                         continue;
 536
 537                         /* ok, now we have a PES header or section header*/
 538                 unsigned char *sec;
 539
 540                         /* check for adaption field */
 541                 if (packet[3] & 0x20)
 542                 {
 543                         if (packet[4] >= 183)
 544                                 continue;
 545                         sec = packet + packet[4] + 4 + 1;
 546                 } else
 547                         sec = packet + 4;
 548
 549                 if (sec[0])     /* table pointer, assumed to be 0 */
 550                         continue;
 551
 552                 if (sec[1] == 0x02) /* program map section */
 553                 {
 554                         pmt_pid = pid;
 555                         service_id = (sec[4] << 8) | sec[5];
 556                         return 0;
 557                 }
 558         }
 559
 560         return -1;
 561 }