code.vuplus.com Git - vuplus_dvbapp/blob - 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         {
  36                 eDebug("loading streaminfo for %s", filename);
  37                 m_streaminfo.load(filename);
  38         }
  39
  40         if (!m_streaminfo.empty())
  41                 m_use_streaminfo = 1;
  42         else
  43         {
  44 //              eDebug("no recorded stream information available");
  45                 m_use_streaminfo = 0;
  46         }
  47
  48         m_samples_taken = 0;
  49
  50         if (m_file.open(filename, 1) < 0)
  51                 return -1;
  52         return 0;
  53 }
  54
  55 void eDVBTSTools::closeFile()
  56 {
  57         m_file.close();
  58 }
  59
  60 void eDVBTSTools::setSyncPID(int pid)
  61 {
  62         m_pid = pid;
  63 }
  64
  65 void eDVBTSTools::setSearchRange(int maxrange)
  66 {
  67         m_maxrange = maxrange;
  68 }
  69
  70         /* getPTS extracts a pts value from any PID at a given offset. */
  71 int eDVBTSTools::getPTS(off_t &offset, pts_t &pts, int fixed)
  72 {
  73         if (m_use_streaminfo)
  74                 if (!m_streaminfo.getPTS(offset, pts))
  75                         return 0;
  76
  77         if (!m_file.valid())
  78                 return -1;
  79
  80         offset -= offset % 188;
  81
  82         if (m_file.lseek(offset, SEEK_SET) < 0)
  83         {
  84                 eDebug("lseek failed");
  85                 return -1;
  86         }
  87
  88         int left = m_maxrange;
  89
  90         while (left >= 188)
  91         {
  92                 unsigned char packet[188];
  93                 if (m_file.read(packet, 188) != 188)
  94                 {
  95                         eDebug("read error");
  96                         break;
  97                 }
  98                 left -= 188;
  99                 offset += 188;
 100
 101                 if (packet[0] != 0x47)
 102                 {
 103                         eDebug("resync");
 104                         int i = 0;
 105                         while (i < 188)
 106                         {
 107                                 if (packet[i] == 0x47)
 108                                         break;
 109                                 ++i;
 110                         }
 111                         offset = m_file.lseek(i - 188, SEEK_CUR);
 112                         continue;
 113                 }
 114
 115                 int pid = ((packet[1] << 8) | packet[2]) & 0x1FFF;
 116                 int pusi = !!(packet[1] & 0x40);
 117
 118 //              printf("PID %04x, PUSI %d\n", pid, pusi);
 119
 120                 unsigned char *payload;
 121
 122                         /* check for adaption field */
 123                 if (packet[3] & 0x20)
 124                 {
 125                         if (packet[4] >= 183)
 126                                 continue;
 127                         if (packet[4])
 128                         {
 129                                 if (packet[5] & 0x10) /* PCR present */
 130                                 {
 131                                         pts  = ((unsigned long long)(packet[ 6]&0xFF)) << 25;
 132                                         pts |= ((unsigned long long)(packet[ 7]&0xFF)) << 17;
 133                                         pts |= ((unsigned long long)(packet[ 8]&0xFE)) << 9;
 134                                         pts |= ((unsigned long long)(packet[ 9]&0xFF)) << 1;
 135                                         pts |= ((unsigned long long)(packet[10]&0x80)) >> 7;
 136                                         offset -= 188;
 137                                         eDebug("PCR %16llx found at %lld pid %02x (%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x)", pts, offset, pid, packet[0], packet[1], packet[2], packet[3], packet[4], packet[5], packet[6], packet[7], packet[8], packet[9], packet[10]);
 138                                         if (fixed && fixupPTS(offset, pts))
 139                                                 return -1;
 140                                         return 0;
 141                                 }
 142                         }
 143                         payload = packet + packet[4] + 4 + 1;
 144                 } else
 145                         payload = packet + 4;
 146
 147
 148 /*              if (m_pid >= 0)
 149                         if (pid != m_pid)
 150                                 continue; */
 151                 if (!pusi)
 152                         continue;
 153
 154
 155                         /* somehow not a startcode. (this is invalid, since pusi was set.) ignore it. */
 156                 if (payload[0] || payload[1] || (payload[2] != 1))
 157                         continue;
 158
 159                         /* drop non-audio, non-video packets because other streams
 160                            can be non-compliant.*/
 161                 if (((payload[3] & 0xE0) != 0xC0) &&  // audio
 162                     ((payload[3] & 0xF0) != 0xE0))    // video
 163                         continue;
 164
 165                 if (payload[7] & 0x80) /* PTS */
 166                 {
 167                         pts  = ((unsigned long long)(payload[ 9]&0xE))  << 29;
 168                         pts |= ((unsigned long long)(payload[10]&0xFF)) << 22;
 169                         pts |= ((unsigned long long)(payload[11]&0xFE)) << 14;
 170                         pts |= ((unsigned long long)(payload[12]&0xFF)) << 7;
 171                         pts |= ((unsigned long long)(payload[13]&0xFE)) >> 1;
 172                         offset -= 188;
 173
 174                         eDebug("PTS %16llx found at %lld pid %02x stream: %02x", pts, offset, pid, payload[3]);
 175
 176                                 /* convert to zero-based */
 177                         if (fixed && fixupPTS(offset, pts))
 178                                 return -1;
 179                         return 0;
 180                 }
 181         }
 182
 183         return -1;
 184 }
 185
 186 int eDVBTSTools::fixupPTS(const off_t &offset, pts_t &now)
 187 {
 188         if (m_use_streaminfo)
 189         {
 190                 if (!m_streaminfo.fixupPTS(offset, now))
 191                         return 0;
 192         } else
 193         {
 194                         /* for the simple case, we assume one epoch, with up to one wrap around in the middle. */
 195                 calcBegin();
 196                 if (!m_begin_valid)
 197                 {
 198                         eDebug("begin not valid, can't fixup");
 199                         return -1;
 200                 }
 201
 202                 pts_t pos = m_pts_begin;
 203                 if ((now < pos) && ((pos - now) < 90000 * 10))
 204                 {
 205                         pos = 0;
 206                         return 0;
 207                 }
 208
 209                 if (now < pos) /* wrap around */
 210                         now = now + 0x200000000LL - pos;
 211                 else
 212                         now -= pos;
 213                 return 0;
 214         }
 215         eDebug("eDVBTSTools::fixupPTS failed!");
 216         return -1;
 217 }
 218
 219 int eDVBTSTools::getOffset(off_t &offset, pts_t &pts, int marg)
 220 {
 221         eDebug("getOffset for pts 0x%llx", pts);
 222         if (m_use_streaminfo)
 223         {
 224                 if (pts >= m_pts_end && marg > 0 && m_end_valid)
 225                         offset = m_offset_end;
 226                 else
 227                         offset = m_streaminfo.getAccessPoint(pts, marg);
 228                 return 0;
 229         } else
 230         {
 231                 calcBegin(); calcEnd();
 232
 233                 if (!m_begin_valid)
 234                         return -1;
 235                 if (!m_end_valid)
 236                         return -1;
 237
 238                 if (!m_samples_taken)
 239                         takeSamples();
 240
 241                 if (!m_samples.empty())
 242                 {
 243                         int maxtries = 5;
 244                         pts_t p = -1;
 245
 246                         while (maxtries--)
 247                         {
 248                                         /* search entry before and after */
 249                                 std::map<pts_t, off_t>::const_iterator l = m_samples.lower_bound(pts);
 250                                 std::map<pts_t, off_t>::const_iterator u = l;
 251
 252                                 if (l != m_samples.begin())
 253                                         --l;
 254
 255                                         /* we could have seeked beyond the end */
 256                                 if (u == m_samples.end())
 257                                 {
 258                                                 /* use last segment for interpolation. */
 259                                         if (l != m_samples.begin())
 260                                         {
 261                                                 --u;
 262                                                 --l;
 263                                         }
 264                                 }
 265
 266                                         /* if we don't have enough points */
 267                                 if (u == m_samples.end())
 268                                         break;
 269
 270                                 pts_t pts_diff = u->first - l->first;
 271                                 off_t offset_diff = u->second - l->second;
 272
 273                                 if (offset_diff < 0)
 274                                 {
 275                                         eDebug("something went wrong when taking samples.");
 276                                         m_samples.clear();
 277                                         takeSamples();
 278                                         continue;
 279                                 }
 280
 281                                 eDebug("using: %llx:%llx -> %llx:%llx", l->first, u->first, l->second, u->second);
 282
 283                                 int bitrate;
 284
 285                                 if (pts_diff)
 286                                         bitrate = offset_diff * 90000 * 8 / pts_diff;
 287                                 else
 288                                         bitrate = 0;
 289
 290                                 offset = l->second;
 291                                 offset += ((pts - l->first) * (pts_t)bitrate) / 8ULL / 90000ULL;
 292                                 offset -= offset % 188;
 293
 294                                 p = pts;
 295
 296                                 if (!takeSample(offset, p))
 297                                 {
 298                                         int diff = (p - pts) / 90;
 299
 300                                         eDebug("calculated diff %d ms", diff);
 301                                         if (abs(diff) > 300)
 302                                         {
 303                                                 eDebug("diff to big, refining");
 304                                                 continue;
 305                                         }
 306                                 } else
 307                                         eDebug("no sample taken, refinement not possible.");
 308
 309                                 break;
 310                         }
 311
 312                                 /* if even the first sample couldn't be taken, fall back. */
 313                                 /* otherwise, return most refined result. */
 314                         if (p != -1)
 315                         {
 316                                 pts = p;
 317                                 eDebug("aborting. Taking %llx as offset for %lld", offset, pts);
 318                                 return 0;
 319                         }
 320                 }
 321
 322                 int bitrate = calcBitrate();
 323                 offset = pts * (pts_t)bitrate / 8ULL / 90000ULL;
 324                 eDebug("fallback, bitrate=%d, results in %016llx", bitrate, offset);
 325                 offset -= offset % 188;
 326
 327                 return 0;
 328         }
 329 }
 330
 331 int eDVBTSTools::getNextAccessPoint(pts_t &ts, const pts_t &start, int direction)
 332 {
 333         if (m_use_streaminfo)
 334                 return m_streaminfo.getNextAccessPoint(ts, start, direction);
 335         else
 336         {
 337                 eDebug("can't get next access point without streaminfo");
 338                 return -1;
 339         }
 340 }
 341
 342 void eDVBTSTools::calcBegin()
 343 {
 344         if (!m_file.valid())
 345                 return;
 346
 347         if (!(m_begin_valid || m_futile))
 348         {
 349                 m_offset_begin = 0;
 350                 if (!getPTS(m_offset_begin, m_pts_begin))
 351                         m_begin_valid = 1;
 352                 else
 353                         m_futile = 1;
 354         }
 355 }
 356
 357 void eDVBTSTools::calcEnd()
 358 {
 359         if (!m_file.valid())
 360                 return;
 361
 362         off_t end = m_file.lseek(0, SEEK_END);
 363
 364         if (llabs(end - m_last_filelength) > 1*1024*1024)
 365         {
 366                 m_last_filelength = end;
 367                 m_end_valid = 0;
 368
 369                 m_futile = 0;
 370 //              eDebug("file size changed, recalc length");
 371         }
 372
 373         int maxiter = 10;
 374
 375         m_offset_end = m_last_filelength;
 376
 377         while (!(m_end_valid || m_futile))
 378         {
 379                 if (!--maxiter)
 380                 {
 381                         m_futile = 1;
 382                         return;
 383                 }
 384
 385                 m_offset_end -= m_maxrange;
 386                 if (m_offset_end < 0)
 387                         m_offset_end = 0;
 388
 389                         /* restore offset if getpts fails */
 390                 off_t off = m_offset_end;
 391
 392                 if (!getPTS(m_offset_end, m_pts_end))
 393                         m_end_valid = 1;
 394                 else
 395                         m_offset_end = off;
 396
 397                 if (!m_offset_end)
 398                 {
 399                         m_futile = 1;
 400                         break;
 401                 }
 402         }
 403 }
 404
 405 int eDVBTSTools::calcLen(pts_t &len)
 406 {
 407         calcBegin(); calcEnd();
 408         if (!(m_begin_valid && m_end_valid))
 409                 return -1;
 410         len = m_pts_end - m_pts_begin;
 411                 /* wrap around? */
 412         if (len < 0)
 413                 len += 0x200000000LL;
 414         return 0;
 415 }
 416
 417 int eDVBTSTools::calcBitrate()
 418 {
 419         calcBegin(); calcEnd();
 420         if (!(m_begin_valid && m_end_valid))
 421                 return -1;
 422
 423         pts_t len_in_pts = m_pts_end - m_pts_begin;
 424
 425                 /* wrap around? */
 426         if (len_in_pts < 0)
 427                 len_in_pts += 0x200000000LL;
 428         off_t len_in_bytes = m_offset_end - m_offset_begin;
 429
 430         if (!len_in_pts)
 431                 return -1;
 432
 433         unsigned long long bitrate = len_in_bytes * 90000 * 8 / len_in_pts;
 434         if ((bitrate < 10000) || (bitrate > 100000000))
 435                 return -1;
 436
 437         return bitrate;
 438 }
 439
 440         /* pts, off */
 441 void eDVBTSTools::takeSamples()
 442 {
 443         m_samples_taken = 1;
 444         m_samples.clear();
 445         pts_t dummy;
 446         int retries=2;
 447
 448         if (calcLen(dummy) == -1)
 449                 return;
 450
 451         int nr_samples = 30;
 452         off_t bytes_per_sample = (m_offset_end - m_offset_begin) / (long long)nr_samples;
 453         if (bytes_per_sample < 40*1024*1024)
 454                 bytes_per_sample = 40*1024*1024;
 455
 456         bytes_per_sample -= bytes_per_sample % 188;
 457
 458         eDebug("samples step %lld, pts begin %llx, pts end %llx, offs begin %lld, offs end %lld:",
 459                 bytes_per_sample, m_pts_begin, m_pts_end, m_offset_begin, m_offset_end);
 460
 461         for (off_t offset = m_offset_begin; offset < m_offset_end;)
 462         {
 463                 pts_t p;
 464                 if (takeSample(offset, p) && retries--)
 465                         continue;
 466                 retries = 2;
 467                 offset += bytes_per_sample;
 468         }
 469         m_samples[0] = m_offset_begin;
 470         m_samples[m_pts_end - m_pts_begin] = m_offset_end;
 471 }
 472
 473         /* returns 0 when a sample was taken. */
 474 int eDVBTSTools::takeSample(off_t off, pts_t &p)
 475 {
 476         off_t offset_org = off;
 477
 478         if (!eDVBTSTools::getPTS(off, p, 1))
 479         {
 480                         /* as we are happily mixing PTS and PCR values (no comment, please), we might
 481                            end up with some "negative" segments.
 482
 483                            so check if this new sample is between the previous and the next field*/
 484
 485                 std::map<pts_t, off_t>::const_iterator l = m_samples.lower_bound(p);
 486                 std::map<pts_t, off_t>::const_iterator u = l;
 487
 488                 if (l != m_samples.begin())
 489                 {
 490                         --l;
 491                         if (u != m_samples.end())
 492                         {
 493                                 if ((l->second > off) || (u->second < off))
 494                                 {
 495                                         eDebug("ignoring sample %lld %lld %lld (%llx %llx %llx)",
 496                                                 l->second, off, u->second, l->first, p, u->first);
 497                                         return 1;
 498                                 }
 499                         }
 500                 }
 501
 502                 eDebug("adding sample %lld: pts 0x%llx -> pos %lld (diff %lld bytes)", offset_org, p, off, off-offset_org);
 503                 m_samples[p] = off;
 504                 return 0;
 505         }
 506         return -1;
 507 }
 508
 509 int eDVBTSTools::findPMT(int &pmt_pid, int &service_id)
 510 {
 511                 /* FIXME: this will be factored out soon! */
 512         if (!m_file.valid())
 513         {
 514                 eDebug(" file not valid");
 515                 return -1;
 516         }
 517
 518         if (m_file.lseek(0, SEEK_SET) < 0)
 519         {
 520                 eDebug("seek failed");
 521                 return -1;
 522         }
 523
 524         int left = 5*1024*1024;
 525
 526         while (left >= 188)
 527         {
 528                 unsigned char packet[188];
 529                 if (m_file.read(packet, 188) != 188)
 530                 {
 531                         eDebug("read error");
 532                         break;
 533                 }
 534                 left -= 188;
 535
 536                 if (packet[0] != 0x47)
 537                 {
 538                         int i = 0;
 539                         while (i < 188)
 540                         {
 541                                 if (packet[i] == 0x47)
 542                                         break;
 543                                 ++i;
 544                         }
 545                         m_file.lseek(i - 188, SEEK_CUR);
 546                         continue;
 547                 }
 548
 549                 int pid = ((packet[1] << 8) | packet[2]) & 0x1FFF;
 550
 551                 int pusi = !!(packet[1] & 0x40);
 552
 553                 if (!pusi)
 554                         continue;
 555
 556                         /* ok, now we have a PES header or section header*/
 557                 unsigned char *sec;
 558
 559                         /* check for adaption field */
 560                 if (packet[3] & 0x20)
 561                 {
 562                         if (packet[4] >= 183)
 563                                 continue;
 564                         sec = packet + packet[4] + 4 + 1;
 565                 } else
 566                         sec = packet + 4;
 567
 568                 if (sec[0])     /* table pointer, assumed to be 0 */
 569                         continue;
 570
 571                 if (sec[1] == 0x02) /* program map section */
 572                 {
 573                         pmt_pid = pid;
 574                         service_id = (sec[4] << 8) | sec[5];
 575                         return 0;
 576                 }
 577         }
 578
 579         return -1;
 580 }
 581
 582 int eDVBTSTools::findFrame(off_t &_offset, size_t &len, int &direction, int frame_types)
 583 {
 584         off_t offset = _offset;
 585         int nr_frames = 0;
 586 //      eDebug("trying to find iFrame at %llx", offset);
 587
 588         if (!m_use_streaminfo)
 589         {
 590 //              eDebug("can't get next iframe without streaminfo");
 591                 return -1;
 592         }
 593
 594                                 /* let's find the iframe before the given offset */
 595         unsigned long long data;
 596
 597         if (direction < 0)
 598                 offset--;
 599
 600         while (1)
 601         {
 602                 if (m_streaminfo.getStructureEntry(offset, data, (direction == 0) ? 1 : 0))
 603                 {
 604                         eDebug("getting structure info for origin offset failed.");
 605                         return -1;
 606                 }
 607                 if (offset == 0x7fffffffffffffffLL) /* eof */
 608                 {
 609                         eDebug("reached eof");
 610                         return -1;
 611                 }
 612                         /* data is usually the start code in the lower 8 bit, and the next byte <<8. we extract the picture type from there */
 613                         /* we know that we aren't recording startcode 0x09 for mpeg2, so this is safe */
 614                         /* TODO: check frame_types */
 615                 int is_start = (data & 0xE0FF) == 0x0009; /* H.264 NAL unit access delimiter with I-frame*/
 616                 is_start |= (data & 0x3800FF) == 0x080000; /* MPEG2 picture start code with I-frame */
 617
 618                 int is_frame = ((data & 0xFF) == 0x0009) || ((data & 0xFF) == 0x00); /* H.264 UAD or MPEG2 start code */
 619
 620                 if (is_frame)
 621                 {
 622                         if (direction < 0)
 623                                 --nr_frames;
 624                         else
 625                                 ++nr_frames;
 626                 }
 627 //              eDebug("%08llx@%llx -> %d, %d", data, offset, is_start, nr_frames);
 628                 if (is_start)
 629                         break;
 630
 631                 if (direction == -1)
 632                         --offset; /* move to previous entry */
 633                 else if (direction == +1)
 634                         direction = 0;
 635         }
 636                         /* let's find the next frame after the given offset */
 637         off_t start = offset;
 638
 639         do {
 640                 if (m_streaminfo.getStructureEntry(offset, data, 1))
 641                 {
 642                         eDebug("get next failed");
 643                         return -1;
 644                 }
 645                 if (offset == 0x7fffffffffffffffLL) /* eof */
 646                 {
 647                         eDebug("reached eof (while looking for end of iframe)");
 648                         return -1;
 649                 }
 650 //              eDebug("%08llx@%llx (next)", data, offset);
 651         } while (((data & 0xFF) != 9) && ((data & 0xFF) != 0x00)); /* next frame */
 652
 653                         /* align to TS pkt start */
 654 //      start = start - (start % 188);
 655 //      offset = offset - (offset % 188);
 656
 657         len = offset - start;
 658         _offset = start;
 659         direction = nr_frames;
 660 //      eDebug("result: offset=%llx, len: %ld", offset, (int)len);
 661         return 0;
 662 }
 663
 664 int eDVBTSTools::findNextPicture(off_t &offset, size_t &len, int &distance, int frame_types)
 665 {
 666         int nr_frames, direction;
 667 //      eDebug("trying to move %d frames at %llx", distance, offset);
 668
 669         frame_types = frametypeI; /* TODO: intelligent "allow IP frames when not crossing an I-Frame */
 670
 671         off_t new_offset = offset;
 672         size_t new_len = len;
 673         int first = 1;
 674
 675         if (distance > 0) {
 676                 direction = 0;
 677                 nr_frames = 0;
 678         } else {
 679                 direction = -1;
 680                 nr_frames = -1;
 681                 distance = -distance+1;
 682         }
 683         while (distance > 0)
 684         {
 685                 int dir = direction;
 686                 if (findFrame(new_offset, new_len, dir, frame_types))
 687                 {
 688 //                      eDebug("findFrame failed!\n");
 689                         return -1;
 690                 }
 691
 692                 distance -= abs(dir);
 693
 694 //              eDebug("we moved %d, %d to go frames (now at %llx)", dir, distance, new_offset);
 695
 696                 if (distance >= 0 || direction == 0)
 697                 {
 698                         first = 0;
 699                         offset = new_offset;
 700                         len = new_len;
 701                         nr_frames += abs(dir);
 702                 }
 703                 else if (first) {
 704                         first = 0;
 705                         offset = new_offset;
 706                         len = new_len;
 707                         nr_frames += abs(dir) + distance; // never jump forward during rewind
 708                 }
 709         }
 710
 711         distance = (direction < 0) ? -nr_frames : nr_frames;
 712 //      eDebug("in total, we moved %d frames", nr_frames);
 713
 714         return 0;
 715 }