1 /* 2 * Copyright (C) 2010 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 //#define LOG_NDEBUG 0 18 #define LOG_TAG "ATSParser" 19 #include <utils/Log.h> 20 21 #include "ATSParser.h" 22 23 #include "AnotherPacketSource.h" 24 #include "ESQueue.h" 25 #include "include/avc_utils.h" 26 27 #include <media/stagefright/foundation/ABitReader.h> 28 #include <media/stagefright/foundation/ABuffer.h> 29 #include <media/stagefright/foundation/ADebug.h> 30 #include <media/stagefright/foundation/AMessage.h> 31 #include <media/stagefright/foundation/hexdump.h> 32 #include <media/stagefright/MediaDefs.h> 33 #include <media/stagefright/MediaErrors.h> 34 #include <media/stagefright/MetaData.h> 35 #include <media/stagefright/Utils.h> 36 #include <media/IStreamSource.h> 37 #include <utils/KeyedVector.h> 38 #include <utils/Vector.h> 39 40 #include <inttypes.h> 41 42 namespace android { 43 44 // I want the expression "y" evaluated even if verbose logging is off. 45 #define MY_LOGV(x, y) \ 46 do { unsigned tmp = y; ALOGV(x, tmp); } while (0) 47 48 static const size_t kTSPacketSize = 188; 49 50 struct ATSParser::Program : public RefBase { 51 Program(ATSParser *parser, unsigned programNumber, unsigned programMapPID, 52 int64_t lastRecoveredPTS); 53 54 bool parsePSISection( 55 unsigned pid, ABitReader *br, status_t *err); 56 57 // Pass to appropriate stream according to pid, and set event if it's a PES 58 // with a sync frame. 59 // Note that the method itself does not touch event. 60 bool parsePID( 61 unsigned pid, unsigned continuity_counter, 62 unsigned payload_unit_start_indicator, 63 ABitReader *br, status_t *err, SyncEvent *event); 64 65 void signalDiscontinuity( 66 DiscontinuityType type, const sp<AMessage> &extra); 67 68 void signalEOS(status_t finalResult); 69 70 sp<MediaSource> getSource(SourceType type); 71 bool hasSource(SourceType type) const; 72 73 int64_t convertPTSToTimestamp(uint64_t PTS); 74 75 bool PTSTimeDeltaEstablished() const { 76 return mFirstPTSValid; 77 } 78 79 unsigned number() const { return mProgramNumber; } 80 81 void updateProgramMapPID(unsigned programMapPID) { 82 mProgramMapPID = programMapPID; 83 } 84 85 unsigned programMapPID() const { 86 return mProgramMapPID; 87 } 88 89 uint32_t parserFlags() const { 90 return mParser->mFlags; 91 } 92 93 private: 94 struct StreamInfo { 95 unsigned mType; 96 unsigned mPID; 97 }; 98 99 ATSParser *mParser; 100 unsigned mProgramNumber; 101 unsigned mProgramMapPID; 102 KeyedVector<unsigned, sp<Stream> > mStreams; 103 bool mFirstPTSValid; 104 uint64_t mFirstPTS; 105 int64_t mLastRecoveredPTS; 106 107 status_t parseProgramMap(ABitReader *br); 108 int64_t recoverPTS(uint64_t PTS_33bit); 109 bool switchPIDs(const Vector<StreamInfo> &infos); 110 111 DISALLOW_EVIL_CONSTRUCTORS(Program); 112 }; 113 114 struct ATSParser::Stream : public RefBase { 115 Stream(Program *program, 116 unsigned elementaryPID, 117 unsigned streamType, 118 unsigned PCR_PID); 119 120 unsigned type() const { return mStreamType; } 121 unsigned pid() const { return mElementaryPID; } 122 void setPID(unsigned pid) { mElementaryPID = pid; } 123 124 // Parse the payload and set event when PES with a sync frame is detected. 125 // This method knows when a PES starts; so record mPesStartOffset in that 126 // case. 127 status_t parse( 128 unsigned continuity_counter, 129 unsigned payload_unit_start_indicator, 130 ABitReader *br, 131 SyncEvent *event); 132 133 void signalDiscontinuity( 134 DiscontinuityType type, const sp<AMessage> &extra); 135 136 void signalEOS(status_t finalResult); 137 138 sp<MediaSource> getSource(SourceType type); 139 140 bool isAudio() const; 141 bool isVideo() const; 142 bool isMeta() const; 143 144 protected: 145 virtual ~Stream(); 146 147 private: 148 Program *mProgram; 149 unsigned mElementaryPID; 150 unsigned mStreamType; 151 unsigned mPCR_PID; 152 int32_t mExpectedContinuityCounter; 153 154 sp<ABuffer> mBuffer; 155 sp<AnotherPacketSource> mSource; 156 bool mPayloadStarted; 157 bool mEOSReached; 158 159 uint64_t mPrevPTS; 160 off64_t mPesStartOffset; 161 162 ElementaryStreamQueue *mQueue; 163 164 // Flush accumulated payload if necessary --- i.e. at EOS or at the start of 165 // another payload. event is set if the flushed payload is PES with a sync 166 // frame. 167 status_t flush(SyncEvent *event); 168 // Strip and parse PES headers and pass remaining payload into onPayload 169 // with parsed metadata. event is set if the PES contains a sync frame. 170 status_t parsePES(ABitReader *br, SyncEvent *event); 171 172 // Feed the payload into mQueue and if a packet is identified, queue it 173 // into mSource. If the packet is a sync frame. set event with start offset 174 // and timestamp of the packet. 175 void onPayloadData( 176 unsigned PTS_DTS_flags, uint64_t PTS, uint64_t DTS, 177 const uint8_t *data, size_t size, SyncEvent *event); 178 179 DISALLOW_EVIL_CONSTRUCTORS(Stream); 180 }; 181 182 struct ATSParser::PSISection : public RefBase { 183 PSISection(); 184 185 status_t append(const void *data, size_t size); 186 void setSkipBytes(uint8_t skip); 187 void clear(); 188 189 bool isComplete() const; 190 bool isEmpty() const; 191 bool isCRCOkay() const; 192 193 const uint8_t *data() const; 194 size_t size() const; 195 196 protected: 197 virtual ~PSISection(); 198 199 private: 200 sp<ABuffer> mBuffer; 201 uint8_t mSkipBytes; 202 static uint32_t CRC_TABLE[]; 203 204 DISALLOW_EVIL_CONSTRUCTORS(PSISection); 205 }; 206 207 ATSParser::SyncEvent::SyncEvent(off64_t offset) 208 : mInit(false), mOffset(offset), mTimeUs(0) {} 209 210 void ATSParser::SyncEvent::init(off64_t offset, const sp<MediaSource> &source, 211 int64_t timeUs) { 212 mInit = true; 213 mOffset = offset; 214 mMediaSource = source; 215 mTimeUs = timeUs; 216 } 217 218 //////////////////////////////////////////////////////////////////////////////// 219 220 ATSParser::Program::Program( 221 ATSParser *parser, unsigned programNumber, unsigned programMapPID, 222 int64_t lastRecoveredPTS) 223 : mParser(parser), 224 mProgramNumber(programNumber), 225 mProgramMapPID(programMapPID), 226 mFirstPTSValid(false), 227 mFirstPTS(0), 228 mLastRecoveredPTS(lastRecoveredPTS) { 229 ALOGV("new program number %u", programNumber); 230 } 231 232 bool ATSParser::Program::parsePSISection( 233 unsigned pid, ABitReader *br, status_t *err) { 234 *err = OK; 235 236 if (pid != mProgramMapPID) { 237 return false; 238 } 239 240 *err = parseProgramMap(br); 241 242 return true; 243 } 244 245 bool ATSParser::Program::parsePID( 246 unsigned pid, unsigned continuity_counter, 247 unsigned payload_unit_start_indicator, 248 ABitReader *br, status_t *err, SyncEvent *event) { 249 *err = OK; 250 251 ssize_t index = mStreams.indexOfKey(pid); 252 if (index < 0) { 253 return false; 254 } 255 256 *err = mStreams.editValueAt(index)->parse( 257 continuity_counter, payload_unit_start_indicator, br, event); 258 259 return true; 260 } 261 262 void ATSParser::Program::signalDiscontinuity( 263 DiscontinuityType type, const sp<AMessage> &extra) { 264 int64_t mediaTimeUs; 265 if ((type & DISCONTINUITY_TIME) 266 && extra != NULL 267 && extra->findInt64( 268 IStreamListener::kKeyMediaTimeUs, &mediaTimeUs)) { 269 mFirstPTSValid = false; 270 } 271 272 for (size_t i = 0; i < mStreams.size(); ++i) { 273 mStreams.editValueAt(i)->signalDiscontinuity(type, extra); 274 } 275 } 276 277 void ATSParser::Program::signalEOS(status_t finalResult) { 278 for (size_t i = 0; i < mStreams.size(); ++i) { 279 mStreams.editValueAt(i)->signalEOS(finalResult); 280 } 281 } 282 283 bool ATSParser::Program::switchPIDs(const Vector<StreamInfo> &infos) { 284 bool success = false; 285 286 if (mStreams.size() == infos.size()) { 287 // build type->PIDs map for old and new mapping 288 size_t i; 289 KeyedVector<int32_t, Vector<int32_t> > oldType2PIDs, newType2PIDs; 290 for (i = 0; i < mStreams.size(); ++i) { 291 ssize_t index = oldType2PIDs.indexOfKey(mStreams[i]->type()); 292 if (index < 0) { 293 oldType2PIDs.add(mStreams[i]->type(), Vector<int32_t>()); 294 } 295 oldType2PIDs.editValueFor(mStreams[i]->type()).push_back(mStreams[i]->pid()); 296 } 297 for (i = 0; i < infos.size(); ++i) { 298 ssize_t index = newType2PIDs.indexOfKey(infos[i].mType); 299 if (index < 0) { 300 newType2PIDs.add(infos[i].mType, Vector<int32_t>()); 301 } 302 newType2PIDs.editValueFor(infos[i].mType).push_back(infos[i].mPID); 303 } 304 305 // we can recover if the number of streams for each type hasn't changed 306 if (oldType2PIDs.size() == newType2PIDs.size()) { 307 success = true; 308 for (i = 0; i < oldType2PIDs.size(); ++i) { 309 // KeyedVector is sorted, we just compare key and size of each index 310 if (oldType2PIDs.keyAt(i) != newType2PIDs.keyAt(i) 311 || oldType2PIDs[i].size() != newType2PIDs[i].size()) { 312 success = false; 313 break; 314 } 315 } 316 } 317 318 if (success) { 319 // save current streams to temp 320 KeyedVector<int32_t, sp<Stream> > temp; 321 for (i = 0; i < mStreams.size(); ++i) { 322 temp.add(mStreams.keyAt(i), mStreams.editValueAt(i)); 323 } 324 325 mStreams.clear(); 326 for (i = 0; i < temp.size(); ++i) { 327 // The two checks below shouldn't happen, 328 // we already checked above the stream count matches 329 ssize_t index = newType2PIDs.indexOfKey(temp[i]->type()); 330 if (index < 0) { 331 return false; 332 } 333 Vector<int32_t> &newPIDs = newType2PIDs.editValueAt(index); 334 if (newPIDs.isEmpty()) { 335 return false; 336 } 337 338 // get the next PID for temp[i]->type() in the new PID map 339 Vector<int32_t>::iterator it = newPIDs.begin(); 340 341 // change the PID of the stream, and add it back 342 temp.editValueAt(i)->setPID(*it); 343 mStreams.add(temp[i]->pid(), temp.editValueAt(i)); 344 345 // removed the used PID 346 newPIDs.erase(it); 347 } 348 } 349 } 350 return success; 351 } 352 353 status_t ATSParser::Program::parseProgramMap(ABitReader *br) { 354 unsigned table_id = br->getBits(8); 355 ALOGV(" table_id = %u", table_id); 356 if (table_id != 0x02u) { 357 ALOGE("PMT data error!"); 358 return ERROR_MALFORMED; 359 } 360 unsigned section_syntax_indicator = br->getBits(1); 361 ALOGV(" section_syntax_indicator = %u", section_syntax_indicator); 362 if (section_syntax_indicator != 1u) { 363 ALOGE("PMT data error!"); 364 return ERROR_MALFORMED; 365 } 366 367 br->skipBits(1); // '0' 368 MY_LOGV(" reserved = %u", br->getBits(2)); 369 370 unsigned section_length = br->getBits(12); 371 ALOGV(" section_length = %u", section_length); 372 373 MY_LOGV(" program_number = %u", br->getBits(16)); 374 MY_LOGV(" reserved = %u", br->getBits(2)); 375 MY_LOGV(" version_number = %u", br->getBits(5)); 376 MY_LOGV(" current_next_indicator = %u", br->getBits(1)); 377 MY_LOGV(" section_number = %u", br->getBits(8)); 378 MY_LOGV(" last_section_number = %u", br->getBits(8)); 379 MY_LOGV(" reserved = %u", br->getBits(3)); 380 381 unsigned PCR_PID = br->getBits(13); 382 ALOGV(" PCR_PID = 0x%04x", PCR_PID); 383 384 MY_LOGV(" reserved = %u", br->getBits(4)); 385 386 unsigned program_info_length = br->getBits(12); 387 ALOGV(" program_info_length = %u", program_info_length); 388 389 br->skipBits(program_info_length * 8); // skip descriptors 390 391 Vector<StreamInfo> infos; 392 393 // infoBytesRemaining is the number of bytes that make up the 394 // variable length section of ES_infos. It does not include the 395 // final CRC. 396 size_t infoBytesRemaining = section_length - 9 - program_info_length - 4; 397 398 while (infoBytesRemaining >= 5) { 399 400 unsigned streamType = br->getBits(8); 401 ALOGV(" stream_type = 0x%02x", streamType); 402 403 MY_LOGV(" reserved = %u", br->getBits(3)); 404 405 unsigned elementaryPID = br->getBits(13); 406 ALOGV(" elementary_PID = 0x%04x", elementaryPID); 407 408 MY_LOGV(" reserved = %u", br->getBits(4)); 409 410 unsigned ES_info_length = br->getBits(12); 411 ALOGV(" ES_info_length = %u", ES_info_length); 412 413 #if 0 414 br->skipBits(ES_info_length * 8); // skip descriptors 415 #else 416 unsigned info_bytes_remaining = ES_info_length; 417 while (info_bytes_remaining >= 2) { 418 MY_LOGV(" tag = 0x%02x", br->getBits(8)); 419 420 unsigned descLength = br->getBits(8); 421 ALOGV(" len = %u", descLength); 422 423 if (info_bytes_remaining < descLength) { 424 return ERROR_MALFORMED; 425 } 426 br->skipBits(descLength * 8); 427 428 info_bytes_remaining -= descLength + 2; 429 } 430 #endif 431 432 StreamInfo info; 433 info.mType = streamType; 434 info.mPID = elementaryPID; 435 infos.push(info); 436 437 infoBytesRemaining -= 5 + ES_info_length; 438 } 439 440 if (infoBytesRemaining != 0) { 441 ALOGW("Section data remains unconsumed"); 442 } 443 MY_LOGV(" CRC = 0x%08x", br->getBits(32)); 444 445 bool PIDsChanged = false; 446 for (size_t i = 0; i < infos.size(); ++i) { 447 StreamInfo &info = infos.editItemAt(i); 448 449 ssize_t index = mStreams.indexOfKey(info.mPID); 450 451 if (index >= 0 && mStreams.editValueAt(index)->type() != info.mType) { 452 ALOGI("uh oh. stream PIDs have changed."); 453 PIDsChanged = true; 454 break; 455 } 456 } 457 458 if (PIDsChanged) { 459 #if 0 460 ALOGI("before:"); 461 for (size_t i = 0; i < mStreams.size(); ++i) { 462 sp<Stream> stream = mStreams.editValueAt(i); 463 464 ALOGI("PID 0x%08x => type 0x%02x", stream->pid(), stream->type()); 465 } 466 467 ALOGI("after:"); 468 for (size_t i = 0; i < infos.size(); ++i) { 469 StreamInfo &info = infos.editItemAt(i); 470 471 ALOGI("PID 0x%08x => type 0x%02x", info.mPID, info.mType); 472 } 473 #endif 474 475 // we can recover if number of streams for each type remain the same 476 bool success = switchPIDs(infos); 477 478 if (!success) { 479 ALOGI("Stream PIDs changed and we cannot recover."); 480 return ERROR_MALFORMED; 481 } 482 } 483 484 for (size_t i = 0; i < infos.size(); ++i) { 485 StreamInfo &info = infos.editItemAt(i); 486 487 ssize_t index = mStreams.indexOfKey(info.mPID); 488 489 if (index < 0) { 490 sp<Stream> stream = new Stream( 491 this, info.mPID, info.mType, PCR_PID); 492 493 mStreams.add(info.mPID, stream); 494 } 495 } 496 497 return OK; 498 } 499 500 int64_t ATSParser::Program::recoverPTS(uint64_t PTS_33bit) { 501 // We only have the lower 33-bit of the PTS. It could overflow within a 502 // reasonable amount of time. To handle the wrap-around, use fancy math 503 // to get an extended PTS that is within [-0xffffffff, 0xffffffff] 504 // of the latest recovered PTS. 505 if (mLastRecoveredPTS < 0ll) { 506 // Use the original 33bit number for 1st frame, the reason is that 507 // if 1st frame wraps to negative that's far away from 0, we could 508 // never start. Only start wrapping around from 2nd frame. 509 mLastRecoveredPTS = static_cast<int64_t>(PTS_33bit); 510 } else { 511 mLastRecoveredPTS = static_cast<int64_t>( 512 ((mLastRecoveredPTS - PTS_33bit + 0x100000000ll) 513 & 0xfffffffe00000000ull) | PTS_33bit); 514 // We start from 0, but recovered PTS could be slightly below 0. 515 // Clamp it to 0 as rest of the pipeline doesn't take negative pts. 516 // (eg. video is read first and starts at 0, but audio starts at 0xfffffff0) 517 if (mLastRecoveredPTS < 0ll) { 518 ALOGI("Clamping negative recovered PTS (%" PRId64 ") to 0", mLastRecoveredPTS); 519 mLastRecoveredPTS = 0ll; 520 } 521 } 522 523 return mLastRecoveredPTS; 524 } 525 526 sp<MediaSource> ATSParser::Program::getSource(SourceType type) { 527 size_t index = (type == AUDIO) ? 0 : 0; 528 529 for (size_t i = 0; i < mStreams.size(); ++i) { 530 sp<MediaSource> source = mStreams.editValueAt(i)->getSource(type); 531 if (source != NULL) { 532 if (index == 0) { 533 return source; 534 } 535 --index; 536 } 537 } 538 539 return NULL; 540 } 541 542 bool ATSParser::Program::hasSource(SourceType type) const { 543 for (size_t i = 0; i < mStreams.size(); ++i) { 544 const sp<Stream> &stream = mStreams.valueAt(i); 545 if (type == AUDIO && stream->isAudio()) { 546 return true; 547 } else if (type == VIDEO && stream->isVideo()) { 548 return true; 549 } 550 } 551 552 return false; 553 } 554 555 int64_t ATSParser::Program::convertPTSToTimestamp(uint64_t PTS) { 556 PTS = recoverPTS(PTS); 557 558 if (!(mParser->mFlags & TS_TIMESTAMPS_ARE_ABSOLUTE)) { 559 if (!mFirstPTSValid) { 560 mFirstPTSValid = true; 561 mFirstPTS = PTS; 562 PTS = 0; 563 } else if (PTS < mFirstPTS) { 564 PTS = 0; 565 } else { 566 PTS -= mFirstPTS; 567 } 568 } 569 570 int64_t timeUs = (PTS * 100) / 9; 571 572 if (mParser->mAbsoluteTimeAnchorUs >= 0ll) { 573 timeUs += mParser->mAbsoluteTimeAnchorUs; 574 } 575 576 if (mParser->mTimeOffsetValid) { 577 timeUs += mParser->mTimeOffsetUs; 578 } 579 580 return timeUs; 581 } 582 583 //////////////////////////////////////////////////////////////////////////////// 584 585 ATSParser::Stream::Stream( 586 Program *program, 587 unsigned elementaryPID, 588 unsigned streamType, 589 unsigned PCR_PID) 590 : mProgram(program), 591 mElementaryPID(elementaryPID), 592 mStreamType(streamType), 593 mPCR_PID(PCR_PID), 594 mExpectedContinuityCounter(-1), 595 mPayloadStarted(false), 596 mEOSReached(false), 597 mPrevPTS(0), 598 mQueue(NULL) { 599 switch (mStreamType) { 600 case STREAMTYPE_H264: 601 mQueue = new ElementaryStreamQueue( 602 ElementaryStreamQueue::H264, 603 (mProgram->parserFlags() & ALIGNED_VIDEO_DATA) 604 ? ElementaryStreamQueue::kFlag_AlignedData : 0); 605 break; 606 case STREAMTYPE_MPEG2_AUDIO_ADTS: 607 mQueue = new ElementaryStreamQueue(ElementaryStreamQueue::AAC); 608 break; 609 case STREAMTYPE_MPEG1_AUDIO: 610 case STREAMTYPE_MPEG2_AUDIO: 611 mQueue = new ElementaryStreamQueue( 612 ElementaryStreamQueue::MPEG_AUDIO); 613 break; 614 615 case STREAMTYPE_MPEG1_VIDEO: 616 case STREAMTYPE_MPEG2_VIDEO: 617 mQueue = new ElementaryStreamQueue( 618 ElementaryStreamQueue::MPEG_VIDEO); 619 break; 620 621 case STREAMTYPE_MPEG4_VIDEO: 622 mQueue = new ElementaryStreamQueue( 623 ElementaryStreamQueue::MPEG4_VIDEO); 624 break; 625 626 case STREAMTYPE_LPCM_AC3: 627 case STREAMTYPE_AC3: 628 mQueue = new ElementaryStreamQueue( 629 ElementaryStreamQueue::AC3); 630 break; 631 632 case STREAMTYPE_METADATA: 633 mQueue = new ElementaryStreamQueue( 634 ElementaryStreamQueue::METADATA); 635 break; 636 637 default: 638 break; 639 } 640 641 ALOGV("new stream PID 0x%02x, type 0x%02x", elementaryPID, streamType); 642 643 if (mQueue != NULL) { 644 mBuffer = new ABuffer(192 * 1024); 645 mBuffer->setRange(0, 0); 646 } 647 } 648 649 ATSParser::Stream::~Stream() { 650 delete mQueue; 651 mQueue = NULL; 652 } 653 654 status_t ATSParser::Stream::parse( 655 unsigned continuity_counter, 656 unsigned payload_unit_start_indicator, ABitReader *br, 657 SyncEvent *event) { 658 if (mQueue == NULL) { 659 return OK; 660 } 661 662 if (mExpectedContinuityCounter >= 0 663 && (unsigned)mExpectedContinuityCounter != continuity_counter) { 664 ALOGI("discontinuity on stream pid 0x%04x", mElementaryPID); 665 666 mPayloadStarted = false; 667 mBuffer->setRange(0, 0); 668 mExpectedContinuityCounter = -1; 669 670 #if 0 671 // Uncomment this if you'd rather see no corruption whatsoever on 672 // screen and suspend updates until we come across another IDR frame. 673 674 if (mStreamType == STREAMTYPE_H264) { 675 ALOGI("clearing video queue"); 676 mQueue->clear(true /* clearFormat */); 677 } 678 #endif 679 680 if (!payload_unit_start_indicator) { 681 return OK; 682 } 683 } 684 685 mExpectedContinuityCounter = (continuity_counter + 1) & 0x0f; 686 687 if (payload_unit_start_indicator) { 688 off64_t offset = (event != NULL) ? event->getOffset() : 0; 689 if (mPayloadStarted) { 690 // Otherwise we run the danger of receiving the trailing bytes 691 // of a PES packet that we never saw the start of and assuming 692 // we have a a complete PES packet. 693 694 status_t err = flush(event); 695 696 if (err != OK) { 697 ALOGW("Error (%08x) happened while flushing; we simply discard " 698 "the PES packet and continue.", err); 699 } 700 } 701 702 mPayloadStarted = true; 703 mPesStartOffset = offset; 704 } 705 706 if (!mPayloadStarted) { 707 return OK; 708 } 709 710 size_t payloadSizeBits = br->numBitsLeft(); 711 if (payloadSizeBits % 8 != 0u) { 712 ALOGE("Wrong value"); 713 return BAD_VALUE; 714 } 715 716 size_t neededSize = mBuffer->size() + payloadSizeBits / 8; 717 if (mBuffer->capacity() < neededSize) { 718 // Increment in multiples of 64K. 719 neededSize = (neededSize + 65535) & ~65535; 720 721 ALOGI("resizing buffer to %zu bytes", neededSize); 722 723 sp<ABuffer> newBuffer = new ABuffer(neededSize); 724 memcpy(newBuffer->data(), mBuffer->data(), mBuffer->size()); 725 newBuffer->setRange(0, mBuffer->size()); 726 mBuffer = newBuffer; 727 } 728 729 memcpy(mBuffer->data() + mBuffer->size(), br->data(), payloadSizeBits / 8); 730 mBuffer->setRange(0, mBuffer->size() + payloadSizeBits / 8); 731 732 return OK; 733 } 734 735 bool ATSParser::Stream::isVideo() const { 736 switch (mStreamType) { 737 case STREAMTYPE_H264: 738 case STREAMTYPE_MPEG1_VIDEO: 739 case STREAMTYPE_MPEG2_VIDEO: 740 case STREAMTYPE_MPEG4_VIDEO: 741 return true; 742 743 default: 744 return false; 745 } 746 } 747 748 bool ATSParser::Stream::isAudio() const { 749 switch (mStreamType) { 750 case STREAMTYPE_MPEG1_AUDIO: 751 case STREAMTYPE_MPEG2_AUDIO: 752 case STREAMTYPE_MPEG2_AUDIO_ADTS: 753 case STREAMTYPE_LPCM_AC3: 754 case STREAMTYPE_AC3: 755 return true; 756 757 default: 758 return false; 759 } 760 } 761 762 bool ATSParser::Stream::isMeta() const { 763 if (mStreamType == STREAMTYPE_METADATA) { 764 return true; 765 } 766 return false; 767 } 768 769 void ATSParser::Stream::signalDiscontinuity( 770 DiscontinuityType type, const sp<AMessage> &extra) { 771 mExpectedContinuityCounter = -1; 772 773 if (mQueue == NULL) { 774 return; 775 } 776 777 mPayloadStarted = false; 778 mEOSReached = false; 779 mBuffer->setRange(0, 0); 780 781 bool clearFormat = false; 782 if (isAudio()) { 783 if (type & DISCONTINUITY_AUDIO_FORMAT) { 784 clearFormat = true; 785 } 786 } else { 787 if (type & DISCONTINUITY_VIDEO_FORMAT) { 788 clearFormat = true; 789 } 790 } 791 792 mQueue->clear(clearFormat); 793 794 if (type & DISCONTINUITY_TIME) { 795 uint64_t resumeAtPTS; 796 if (extra != NULL 797 && extra->findInt64( 798 IStreamListener::kKeyResumeAtPTS, 799 (int64_t *)&resumeAtPTS)) { 800 int64_t resumeAtMediaTimeUs = 801 mProgram->convertPTSToTimestamp(resumeAtPTS); 802 803 extra->setInt64("resume-at-mediaTimeUs", resumeAtMediaTimeUs); 804 } 805 } 806 807 if (mSource != NULL) { 808 mSource->queueDiscontinuity(type, extra, true); 809 } 810 } 811 812 void ATSParser::Stream::signalEOS(status_t finalResult) { 813 if (mSource != NULL) { 814 mSource->signalEOS(finalResult); 815 } 816 mEOSReached = true; 817 flush(NULL); 818 } 819 820 status_t ATSParser::Stream::parsePES(ABitReader *br, SyncEvent *event) { 821 unsigned packet_startcode_prefix = br->getBits(24); 822 823 ALOGV("packet_startcode_prefix = 0x%08x", packet_startcode_prefix); 824 825 if (packet_startcode_prefix != 1) { 826 ALOGV("Supposedly payload_unit_start=1 unit does not start " 827 "with startcode."); 828 829 return ERROR_MALFORMED; 830 } 831 832 unsigned stream_id = br->getBits(8); 833 ALOGV("stream_id = 0x%02x", stream_id); 834 835 unsigned PES_packet_length = br->getBits(16); 836 ALOGV("PES_packet_length = %u", PES_packet_length); 837 838 if (stream_id != 0xbc // program_stream_map 839 && stream_id != 0xbe // padding_stream 840 && stream_id != 0xbf // private_stream_2 841 && stream_id != 0xf0 // ECM 842 && stream_id != 0xf1 // EMM 843 && stream_id != 0xff // program_stream_directory 844 && stream_id != 0xf2 // DSMCC 845 && stream_id != 0xf8) { // H.222.1 type E 846 if (br->getBits(2) != 2u) { 847 return ERROR_MALFORMED; 848 } 849 850 MY_LOGV("PES_scrambling_control = %u", br->getBits(2)); 851 MY_LOGV("PES_priority = %u", br->getBits(1)); 852 MY_LOGV("data_alignment_indicator = %u", br->getBits(1)); 853 MY_LOGV("copyright = %u", br->getBits(1)); 854 MY_LOGV("original_or_copy = %u", br->getBits(1)); 855 856 unsigned PTS_DTS_flags = br->getBits(2); 857 ALOGV("PTS_DTS_flags = %u", PTS_DTS_flags); 858 859 unsigned ESCR_flag = br->getBits(1); 860 ALOGV("ESCR_flag = %u", ESCR_flag); 861 862 unsigned ES_rate_flag = br->getBits(1); 863 ALOGV("ES_rate_flag = %u", ES_rate_flag); 864 865 unsigned DSM_trick_mode_flag = br->getBits(1); 866 ALOGV("DSM_trick_mode_flag = %u", DSM_trick_mode_flag); 867 868 unsigned additional_copy_info_flag = br->getBits(1); 869 ALOGV("additional_copy_info_flag = %u", additional_copy_info_flag); 870 871 MY_LOGV("PES_CRC_flag = %u", br->getBits(1)); 872 MY_LOGV("PES_extension_flag = %u", br->getBits(1)); 873 874 unsigned PES_header_data_length = br->getBits(8); 875 ALOGV("PES_header_data_length = %u", PES_header_data_length); 876 877 unsigned optional_bytes_remaining = PES_header_data_length; 878 879 uint64_t PTS = 0, DTS = 0; 880 881 if (PTS_DTS_flags == 2 || PTS_DTS_flags == 3) { 882 if (optional_bytes_remaining < 5u) { 883 return ERROR_MALFORMED; 884 } 885 886 if (br->getBits(4) != PTS_DTS_flags) { 887 return ERROR_MALFORMED; 888 } 889 PTS = ((uint64_t)br->getBits(3)) << 30; 890 if (br->getBits(1) != 1u) { 891 return ERROR_MALFORMED; 892 } 893 PTS |= ((uint64_t)br->getBits(15)) << 15; 894 if (br->getBits(1) != 1u) { 895 return ERROR_MALFORMED; 896 } 897 PTS |= br->getBits(15); 898 if (br->getBits(1) != 1u) { 899 return ERROR_MALFORMED; 900 } 901 902 ALOGV("PTS = 0x%016" PRIx64 " (%.2f)", PTS, PTS / 90000.0); 903 904 optional_bytes_remaining -= 5; 905 906 if (PTS_DTS_flags == 3) { 907 if (optional_bytes_remaining < 5u) { 908 return ERROR_MALFORMED; 909 } 910 911 if (br->getBits(4) != 1u) { 912 return ERROR_MALFORMED; 913 } 914 915 DTS = ((uint64_t)br->getBits(3)) << 30; 916 if (br->getBits(1) != 1u) { 917 return ERROR_MALFORMED; 918 } 919 DTS |= ((uint64_t)br->getBits(15)) << 15; 920 if (br->getBits(1) != 1u) { 921 return ERROR_MALFORMED; 922 } 923 DTS |= br->getBits(15); 924 if (br->getBits(1) != 1u) { 925 return ERROR_MALFORMED; 926 } 927 928 ALOGV("DTS = %" PRIu64, DTS); 929 930 optional_bytes_remaining -= 5; 931 } 932 } 933 934 if (ESCR_flag) { 935 if (optional_bytes_remaining < 6u) { 936 return ERROR_MALFORMED; 937 } 938 939 br->getBits(2); 940 941 uint64_t ESCR = ((uint64_t)br->getBits(3)) << 30; 942 if (br->getBits(1) != 1u) { 943 return ERROR_MALFORMED; 944 } 945 ESCR |= ((uint64_t)br->getBits(15)) << 15; 946 if (br->getBits(1) != 1u) { 947 return ERROR_MALFORMED; 948 } 949 ESCR |= br->getBits(15); 950 if (br->getBits(1) != 1u) { 951 return ERROR_MALFORMED; 952 } 953 954 ALOGV("ESCR = %" PRIu64, ESCR); 955 MY_LOGV("ESCR_extension = %u", br->getBits(9)); 956 957 if (br->getBits(1) != 1u) { 958 return ERROR_MALFORMED; 959 } 960 961 optional_bytes_remaining -= 6; 962 } 963 964 if (ES_rate_flag) { 965 if (optional_bytes_remaining < 3u) { 966 return ERROR_MALFORMED; 967 } 968 969 if (br->getBits(1) != 1u) { 970 return ERROR_MALFORMED; 971 } 972 MY_LOGV("ES_rate = %u", br->getBits(22)); 973 if (br->getBits(1) != 1u) { 974 return ERROR_MALFORMED; 975 } 976 977 optional_bytes_remaining -= 3; 978 } 979 980 br->skipBits(optional_bytes_remaining * 8); 981 982 // ES data follows. 983 984 if (PES_packet_length != 0) { 985 if (PES_packet_length < PES_header_data_length + 3) { 986 return ERROR_MALFORMED; 987 } 988 989 unsigned dataLength = 990 PES_packet_length - 3 - PES_header_data_length; 991 992 if (br->numBitsLeft() < dataLength * 8) { 993 ALOGE("PES packet does not carry enough data to contain " 994 "payload. (numBitsLeft = %zu, required = %u)", 995 br->numBitsLeft(), dataLength * 8); 996 997 return ERROR_MALFORMED; 998 } 999 1000 onPayloadData( 1001 PTS_DTS_flags, PTS, DTS, br->data(), dataLength, event); 1002 1003 br->skipBits(dataLength * 8); 1004 } else { 1005 onPayloadData( 1006 PTS_DTS_flags, PTS, DTS, 1007 br->data(), br->numBitsLeft() / 8, event); 1008 1009 size_t payloadSizeBits = br->numBitsLeft(); 1010 if (payloadSizeBits % 8 != 0u) { 1011 return ERROR_MALFORMED; 1012 } 1013 1014 ALOGV("There's %zu bytes of payload.", payloadSizeBits / 8); 1015 } 1016 } else if (stream_id == 0xbe) { // padding_stream 1017 if (PES_packet_length == 0u) { 1018 return ERROR_MALFORMED; 1019 } 1020 br->skipBits(PES_packet_length * 8); 1021 } else { 1022 if (PES_packet_length == 0u) { 1023 return ERROR_MALFORMED; 1024 } 1025 br->skipBits(PES_packet_length * 8); 1026 } 1027 1028 return OK; 1029 } 1030 1031 status_t ATSParser::Stream::flush(SyncEvent *event) { 1032 if (mBuffer == NULL || mBuffer->size() == 0) { 1033 return OK; 1034 } 1035 1036 ALOGV("flushing stream 0x%04x size = %zu", mElementaryPID, mBuffer->size()); 1037 1038 ABitReader br(mBuffer->data(), mBuffer->size()); 1039 1040 status_t err = parsePES(&br, event); 1041 1042 mBuffer->setRange(0, 0); 1043 1044 return err; 1045 } 1046 1047 void ATSParser::Stream::onPayloadData( 1048 unsigned PTS_DTS_flags, uint64_t PTS, uint64_t /* DTS */, 1049 const uint8_t *data, size_t size, SyncEvent *event) { 1050 #if 0 1051 ALOGI("payload streamType 0x%02x, PTS = 0x%016llx, dPTS = %lld", 1052 mStreamType, 1053 PTS, 1054 (int64_t)PTS - mPrevPTS); 1055 mPrevPTS = PTS; 1056 #endif 1057 1058 ALOGV("onPayloadData mStreamType=0x%02x", mStreamType); 1059 1060 int64_t timeUs = 0ll; // no presentation timestamp available. 1061 if (PTS_DTS_flags == 2 || PTS_DTS_flags == 3) { 1062 timeUs = mProgram->convertPTSToTimestamp(PTS); 1063 } 1064 1065 status_t err = mQueue->appendData(data, size, timeUs); 1066 1067 if (mEOSReached) { 1068 mQueue->signalEOS(); 1069 } 1070 1071 if (err != OK) { 1072 return; 1073 } 1074 1075 sp<ABuffer> accessUnit; 1076 bool found = false; 1077 while ((accessUnit = mQueue->dequeueAccessUnit()) != NULL) { 1078 if (mSource == NULL) { 1079 sp<MetaData> meta = mQueue->getFormat(); 1080 1081 if (meta != NULL) { 1082 ALOGV("Stream PID 0x%08x of type 0x%02x now has data.", 1083 mElementaryPID, mStreamType); 1084 1085 const char *mime; 1086 if (meta->findCString(kKeyMIMEType, &mime) 1087 && !strcasecmp(mime, MEDIA_MIMETYPE_VIDEO_AVC) 1088 && !IsIDR(accessUnit)) { 1089 continue; 1090 } 1091 mSource = new AnotherPacketSource(meta); 1092 mSource->queueAccessUnit(accessUnit); 1093 } 1094 } else if (mQueue->getFormat() != NULL) { 1095 // After a discontinuity we invalidate the queue's format 1096 // and won't enqueue any access units to the source until 1097 // the queue has reestablished the new format. 1098 1099 if (mSource->getFormat() == NULL) { 1100 mSource->setFormat(mQueue->getFormat()); 1101 } 1102 mSource->queueAccessUnit(accessUnit); 1103 } 1104 1105 if ((event != NULL) && !found && mQueue->getFormat() != NULL) { 1106 int32_t sync = 0; 1107 if (accessUnit->meta()->findInt32("isSync", &sync) && sync) { 1108 int64_t timeUs; 1109 if (accessUnit->meta()->findInt64("timeUs", &timeUs)) { 1110 found = true; 1111 event->init(mPesStartOffset, mSource, timeUs); 1112 } 1113 } 1114 } 1115 } 1116 } 1117 1118 sp<MediaSource> ATSParser::Stream::getSource(SourceType type) { 1119 switch (type) { 1120 case VIDEO: 1121 { 1122 if (isVideo()) { 1123 return mSource; 1124 } 1125 break; 1126 } 1127 1128 case AUDIO: 1129 { 1130 if (isAudio()) { 1131 return mSource; 1132 } 1133 break; 1134 } 1135 1136 case META: 1137 { 1138 if (isMeta()) { 1139 return mSource; 1140 } 1141 break; 1142 } 1143 1144 default: 1145 break; 1146 } 1147 1148 return NULL; 1149 } 1150 1151 //////////////////////////////////////////////////////////////////////////////// 1152 1153 ATSParser::ATSParser(uint32_t flags) 1154 : mFlags(flags), 1155 mAbsoluteTimeAnchorUs(-1ll), 1156 mTimeOffsetValid(false), 1157 mTimeOffsetUs(0ll), 1158 mLastRecoveredPTS(-1ll), 1159 mNumTSPacketsParsed(0), 1160 mNumPCRs(0) { 1161 mPSISections.add(0 /* PID */, new PSISection); 1162 } 1163 1164 ATSParser::~ATSParser() { 1165 } 1166 1167 status_t ATSParser::feedTSPacket(const void *data, size_t size, 1168 SyncEvent *event) { 1169 if (size != kTSPacketSize) { 1170 ALOGE("Wrong TS packet size"); 1171 return BAD_VALUE; 1172 } 1173 1174 ABitReader br((const uint8_t *)data, kTSPacketSize); 1175 return parseTS(&br, event); 1176 } 1177 1178 void ATSParser::signalDiscontinuity( 1179 DiscontinuityType type, const sp<AMessage> &extra) { 1180 int64_t mediaTimeUs; 1181 if ((type & DISCONTINUITY_TIME) && extra != NULL) { 1182 if (extra->findInt64(IStreamListener::kKeyMediaTimeUs, &mediaTimeUs)) { 1183 mAbsoluteTimeAnchorUs = mediaTimeUs; 1184 } 1185 if ((mFlags & TS_TIMESTAMPS_ARE_ABSOLUTE) 1186 && extra->findInt64( 1187 IStreamListener::kKeyRecentMediaTimeUs, &mediaTimeUs)) { 1188 if (mAbsoluteTimeAnchorUs >= 0ll) { 1189 mediaTimeUs -= mAbsoluteTimeAnchorUs; 1190 } 1191 if (mTimeOffsetValid) { 1192 mediaTimeUs -= mTimeOffsetUs; 1193 } 1194 mLastRecoveredPTS = (mediaTimeUs * 9) / 100; 1195 } 1196 } else if (type == DISCONTINUITY_ABSOLUTE_TIME) { 1197 int64_t timeUs; 1198 if (!extra->findInt64("timeUs", &timeUs)) { 1199 ALOGE("timeUs not found"); 1200 return; 1201 } 1202 1203 if (!mPrograms.empty()) { 1204 ALOGE("mPrograms is not empty"); 1205 return; 1206 } 1207 mAbsoluteTimeAnchorUs = timeUs; 1208 return; 1209 } else if (type == DISCONTINUITY_TIME_OFFSET) { 1210 int64_t offset; 1211 if (!extra->findInt64("offset", &offset)) { 1212 ALOGE("offset not found"); 1213 return; 1214 } 1215 1216 mTimeOffsetValid = true; 1217 mTimeOffsetUs = offset; 1218 return; 1219 } 1220 1221 for (size_t i = 0; i < mPrograms.size(); ++i) { 1222 mPrograms.editItemAt(i)->signalDiscontinuity(type, extra); 1223 } 1224 } 1225 1226 void ATSParser::signalEOS(status_t finalResult) { 1227 if (finalResult == (status_t) OK) { 1228 ALOGE("finalResult not OK"); 1229 return; 1230 } 1231 1232 for (size_t i = 0; i < mPrograms.size(); ++i) { 1233 mPrograms.editItemAt(i)->signalEOS(finalResult); 1234 } 1235 } 1236 1237 void ATSParser::parseProgramAssociationTable(ABitReader *br) { 1238 unsigned table_id = br->getBits(8); 1239 ALOGV(" table_id = %u", table_id); 1240 if (table_id != 0x00u) { 1241 ALOGE("PAT data error!"); 1242 return ; 1243 } 1244 unsigned section_syntax_indictor = br->getBits(1); 1245 ALOGV(" section_syntax_indictor = %u", section_syntax_indictor); 1246 1247 br->skipBits(1); // '0' 1248 MY_LOGV(" reserved = %u", br->getBits(2)); 1249 1250 unsigned section_length = br->getBits(12); 1251 ALOGV(" section_length = %u", section_length); 1252 1253 MY_LOGV(" transport_stream_id = %u", br->getBits(16)); 1254 MY_LOGV(" reserved = %u", br->getBits(2)); 1255 MY_LOGV(" version_number = %u", br->getBits(5)); 1256 MY_LOGV(" current_next_indicator = %u", br->getBits(1)); 1257 MY_LOGV(" section_number = %u", br->getBits(8)); 1258 MY_LOGV(" last_section_number = %u", br->getBits(8)); 1259 1260 size_t numProgramBytes = (section_length - 5 /* header */ - 4 /* crc */); 1261 1262 for (size_t i = 0; i < numProgramBytes / 4; ++i) { 1263 unsigned program_number = br->getBits(16); 1264 ALOGV(" program_number = %u", program_number); 1265 1266 MY_LOGV(" reserved = %u", br->getBits(3)); 1267 1268 if (program_number == 0) { 1269 MY_LOGV(" network_PID = 0x%04x", br->getBits(13)); 1270 } else { 1271 unsigned programMapPID = br->getBits(13); 1272 1273 ALOGV(" program_map_PID = 0x%04x", programMapPID); 1274 1275 bool found = false; 1276 for (size_t index = 0; index < mPrograms.size(); ++index) { 1277 const sp<Program> &program = mPrograms.itemAt(index); 1278 1279 if (program->number() == program_number) { 1280 program->updateProgramMapPID(programMapPID); 1281 found = true; 1282 break; 1283 } 1284 } 1285 1286 if (!found) { 1287 mPrograms.push( 1288 new Program(this, program_number, programMapPID, mLastRecoveredPTS)); 1289 } 1290 1291 if (mPSISections.indexOfKey(programMapPID) < 0) { 1292 mPSISections.add(programMapPID, new PSISection); 1293 } 1294 } 1295 } 1296 1297 MY_LOGV(" CRC = 0x%08x", br->getBits(32)); 1298 } 1299 1300 status_t ATSParser::parsePID( 1301 ABitReader *br, unsigned PID, 1302 unsigned continuity_counter, 1303 unsigned payload_unit_start_indicator, 1304 SyncEvent *event) { 1305 ssize_t sectionIndex = mPSISections.indexOfKey(PID); 1306 1307 if (sectionIndex >= 0) { 1308 sp<PSISection> section = mPSISections.valueAt(sectionIndex); 1309 1310 if (payload_unit_start_indicator) { 1311 if (!section->isEmpty()) { 1312 ALOGW("parsePID encounters payload_unit_start_indicator when section is not empty"); 1313 section->clear(); 1314 } 1315 1316 unsigned skip = br->getBits(8); 1317 section->setSkipBytes(skip + 1); // skip filler bytes + pointer field itself 1318 br->skipBits(skip * 8); 1319 } 1320 1321 if (br->numBitsLeft() % 8 != 0) { 1322 return ERROR_MALFORMED; 1323 } 1324 status_t err = section->append(br->data(), br->numBitsLeft() / 8); 1325 1326 if (err != OK) { 1327 return err; 1328 } 1329 1330 if (!section->isComplete()) { 1331 return OK; 1332 } 1333 1334 if (!section->isCRCOkay()) { 1335 return BAD_VALUE; 1336 } 1337 ABitReader sectionBits(section->data(), section->size()); 1338 1339 if (PID == 0) { 1340 parseProgramAssociationTable(§ionBits); 1341 } else { 1342 bool handled = false; 1343 for (size_t i = 0; i < mPrograms.size(); ++i) { 1344 status_t err; 1345 if (!mPrograms.editItemAt(i)->parsePSISection( 1346 PID, §ionBits, &err)) { 1347 continue; 1348 } 1349 1350 if (err != OK) { 1351 return err; 1352 } 1353 1354 handled = true; 1355 break; 1356 } 1357 1358 if (!handled) { 1359 mPSISections.removeItem(PID); 1360 section.clear(); 1361 } 1362 } 1363 1364 if (section != NULL) { 1365 section->clear(); 1366 } 1367 1368 return OK; 1369 } 1370 1371 bool handled = false; 1372 for (size_t i = 0; i < mPrograms.size(); ++i) { 1373 status_t err; 1374 if (mPrograms.editItemAt(i)->parsePID( 1375 PID, continuity_counter, payload_unit_start_indicator, 1376 br, &err, event)) { 1377 if (err != OK) { 1378 return err; 1379 } 1380 1381 handled = true; 1382 break; 1383 } 1384 } 1385 1386 if (!handled) { 1387 ALOGV("PID 0x%04x not handled.", PID); 1388 } 1389 1390 return OK; 1391 } 1392 1393 status_t ATSParser::parseAdaptationField(ABitReader *br, unsigned PID) { 1394 unsigned adaptation_field_length = br->getBits(8); 1395 1396 if (adaptation_field_length > 0) { 1397 if (adaptation_field_length * 8 > br->numBitsLeft()) { 1398 ALOGV("Adaptation field should be included in a single TS packet."); 1399 return ERROR_MALFORMED; 1400 } 1401 1402 unsigned discontinuity_indicator = br->getBits(1); 1403 1404 if (discontinuity_indicator) { 1405 ALOGV("PID 0x%04x: discontinuity_indicator = 1 (!!!)", PID); 1406 } 1407 1408 br->skipBits(2); 1409 unsigned PCR_flag = br->getBits(1); 1410 1411 size_t numBitsRead = 4; 1412 1413 if (PCR_flag) { 1414 if (adaptation_field_length * 8 < 52) { 1415 return ERROR_MALFORMED; 1416 } 1417 br->skipBits(4); 1418 uint64_t PCR_base = br->getBits(32); 1419 PCR_base = (PCR_base << 1) | br->getBits(1); 1420 1421 br->skipBits(6); 1422 unsigned PCR_ext = br->getBits(9); 1423 1424 // The number of bytes from the start of the current 1425 // MPEG2 transport stream packet up and including 1426 // the final byte of this PCR_ext field. 1427 size_t byteOffsetFromStartOfTSPacket = 1428 (188 - br->numBitsLeft() / 8); 1429 1430 uint64_t PCR = PCR_base * 300 + PCR_ext; 1431 1432 ALOGV("PID 0x%04x: PCR = 0x%016" PRIx64 " (%.2f)", 1433 PID, PCR, PCR / 27E6); 1434 1435 // The number of bytes received by this parser up to and 1436 // including the final byte of this PCR_ext field. 1437 size_t byteOffsetFromStart = 1438 mNumTSPacketsParsed * 188 + byteOffsetFromStartOfTSPacket; 1439 1440 for (size_t i = 0; i < mPrograms.size(); ++i) { 1441 updatePCR(PID, PCR, byteOffsetFromStart); 1442 } 1443 1444 numBitsRead += 52; 1445 } 1446 1447 br->skipBits(adaptation_field_length * 8 - numBitsRead); 1448 } 1449 return OK; 1450 } 1451 1452 status_t ATSParser::parseTS(ABitReader *br, SyncEvent *event) { 1453 ALOGV("---"); 1454 1455 unsigned sync_byte = br->getBits(8); 1456 if (sync_byte != 0x47u) { 1457 ALOGE("[error] parseTS: return error as sync_byte=0x%x", sync_byte); 1458 return BAD_VALUE; 1459 } 1460 1461 if (br->getBits(1)) { // transport_error_indicator 1462 // silently ignore. 1463 return OK; 1464 } 1465 1466 unsigned payload_unit_start_indicator = br->getBits(1); 1467 ALOGV("payload_unit_start_indicator = %u", payload_unit_start_indicator); 1468 1469 MY_LOGV("transport_priority = %u", br->getBits(1)); 1470 1471 unsigned PID = br->getBits(13); 1472 ALOGV("PID = 0x%04x", PID); 1473 1474 MY_LOGV("transport_scrambling_control = %u", br->getBits(2)); 1475 1476 unsigned adaptation_field_control = br->getBits(2); 1477 ALOGV("adaptation_field_control = %u", adaptation_field_control); 1478 1479 unsigned continuity_counter = br->getBits(4); 1480 ALOGV("PID = 0x%04x, continuity_counter = %u", PID, continuity_counter); 1481 1482 // ALOGI("PID = 0x%04x, continuity_counter = %u", PID, continuity_counter); 1483 1484 status_t err = OK; 1485 1486 if (adaptation_field_control == 2 || adaptation_field_control == 3) { 1487 err = parseAdaptationField(br, PID); 1488 } 1489 if (err == OK) { 1490 if (adaptation_field_control == 1 || adaptation_field_control == 3) { 1491 err = parsePID(br, PID, continuity_counter, 1492 payload_unit_start_indicator, event); 1493 } 1494 } 1495 1496 ++mNumTSPacketsParsed; 1497 1498 return err; 1499 } 1500 1501 sp<MediaSource> ATSParser::getSource(SourceType type) { 1502 int which = -1; // any 1503 1504 for (size_t i = 0; i < mPrograms.size(); ++i) { 1505 const sp<Program> &program = mPrograms.editItemAt(i); 1506 1507 if (which >= 0 && (int)program->number() != which) { 1508 continue; 1509 } 1510 1511 sp<MediaSource> source = program->getSource(type); 1512 1513 if (source != NULL) { 1514 return source; 1515 } 1516 } 1517 1518 return NULL; 1519 } 1520 1521 bool ATSParser::hasSource(SourceType type) const { 1522 for (size_t i = 0; i < mPrograms.size(); ++i) { 1523 const sp<Program> &program = mPrograms.itemAt(i); 1524 if (program->hasSource(type)) { 1525 return true; 1526 } 1527 } 1528 1529 return false; 1530 } 1531 1532 bool ATSParser::PTSTimeDeltaEstablished() { 1533 if (mPrograms.isEmpty()) { 1534 return false; 1535 } 1536 1537 return mPrograms.editItemAt(0)->PTSTimeDeltaEstablished(); 1538 } 1539 1540 void ATSParser::updatePCR( 1541 unsigned /* PID */, uint64_t PCR, size_t byteOffsetFromStart) { 1542 ALOGV("PCR 0x%016" PRIx64 " @ %zu", PCR, byteOffsetFromStart); 1543 1544 if (mNumPCRs == 2) { 1545 mPCR[0] = mPCR[1]; 1546 mPCRBytes[0] = mPCRBytes[1]; 1547 mSystemTimeUs[0] = mSystemTimeUs[1]; 1548 mNumPCRs = 1; 1549 } 1550 1551 mPCR[mNumPCRs] = PCR; 1552 mPCRBytes[mNumPCRs] = byteOffsetFromStart; 1553 mSystemTimeUs[mNumPCRs] = ALooper::GetNowUs(); 1554 1555 ++mNumPCRs; 1556 1557 if (mNumPCRs == 2) { 1558 double transportRate = 1559 (mPCRBytes[1] - mPCRBytes[0]) * 27E6 / (mPCR[1] - mPCR[0]); 1560 1561 ALOGV("transportRate = %.2f bytes/sec", transportRate); 1562 } 1563 } 1564 1565 //////////////////////////////////////////////////////////////////////////////// 1566 1567 1568 // CRC32 used for PSI section. The table was generated by following command: 1569 // $ python pycrc.py --model crc-32-mpeg --algorithm table-driven --generate c 1570 // Visit http://www.tty1.net/pycrc/index_en.html for more details. 1571 uint32_t ATSParser::PSISection::CRC_TABLE[] = { 1572 0x00000000, 0x04c11db7, 0x09823b6e, 0x0d4326d9, 1573 0x130476dc, 0x17c56b6b, 0x1a864db2, 0x1e475005, 1574 0x2608edb8, 0x22c9f00f, 0x2f8ad6d6, 0x2b4bcb61, 1575 0x350c9b64, 0x31cd86d3, 0x3c8ea00a, 0x384fbdbd, 1576 0x4c11db70, 0x48d0c6c7, 0x4593e01e, 0x4152fda9, 1577 0x5f15adac, 0x5bd4b01b, 0x569796c2, 0x52568b75, 1578 0x6a1936c8, 0x6ed82b7f, 0x639b0da6, 0x675a1011, 1579 0x791d4014, 0x7ddc5da3, 0x709f7b7a, 0x745e66cd, 1580 0x9823b6e0, 0x9ce2ab57, 0x91a18d8e, 0x95609039, 1581 0x8b27c03c, 0x8fe6dd8b, 0x82a5fb52, 0x8664e6e5, 1582 0xbe2b5b58, 0xbaea46ef, 0xb7a96036, 0xb3687d81, 1583 0xad2f2d84, 0xa9ee3033, 0xa4ad16ea, 0xa06c0b5d, 1584 0xd4326d90, 0xd0f37027, 0xddb056fe, 0xd9714b49, 1585 0xc7361b4c, 0xc3f706fb, 0xceb42022, 0xca753d95, 1586 0xf23a8028, 0xf6fb9d9f, 0xfbb8bb46, 0xff79a6f1, 1587 0xe13ef6f4, 0xe5ffeb43, 0xe8bccd9a, 0xec7dd02d, 1588 0x34867077, 0x30476dc0, 0x3d044b19, 0x39c556ae, 1589 0x278206ab, 0x23431b1c, 0x2e003dc5, 0x2ac12072, 1590 0x128e9dcf, 0x164f8078, 0x1b0ca6a1, 0x1fcdbb16, 1591 0x018aeb13, 0x054bf6a4, 0x0808d07d, 0x0cc9cdca, 1592 0x7897ab07, 0x7c56b6b0, 0x71159069, 0x75d48dde, 1593 0x6b93dddb, 0x6f52c06c, 0x6211e6b5, 0x66d0fb02, 1594 0x5e9f46bf, 0x5a5e5b08, 0x571d7dd1, 0x53dc6066, 1595 0x4d9b3063, 0x495a2dd4, 0x44190b0d, 0x40d816ba, 1596 0xaca5c697, 0xa864db20, 0xa527fdf9, 0xa1e6e04e, 1597 0xbfa1b04b, 0xbb60adfc, 0xb6238b25, 0xb2e29692, 1598 0x8aad2b2f, 0x8e6c3698, 0x832f1041, 0x87ee0df6, 1599 0x99a95df3, 0x9d684044, 0x902b669d, 0x94ea7b2a, 1600 0xe0b41de7, 0xe4750050, 0xe9362689, 0xedf73b3e, 1601 0xf3b06b3b, 0xf771768c, 0xfa325055, 0xfef34de2, 1602 0xc6bcf05f, 0xc27dede8, 0xcf3ecb31, 0xcbffd686, 1603 0xd5b88683, 0xd1799b34, 0xdc3abded, 0xd8fba05a, 1604 0x690ce0ee, 0x6dcdfd59, 0x608edb80, 0x644fc637, 1605 0x7a089632, 0x7ec98b85, 0x738aad5c, 0x774bb0eb, 1606 0x4f040d56, 0x4bc510e1, 0x46863638, 0x42472b8f, 1607 0x5c007b8a, 0x58c1663d, 0x558240e4, 0x51435d53, 1608 0x251d3b9e, 0x21dc2629, 0x2c9f00f0, 0x285e1d47, 1609 0x36194d42, 0x32d850f5, 0x3f9b762c, 0x3b5a6b9b, 1610 0x0315d626, 0x07d4cb91, 0x0a97ed48, 0x0e56f0ff, 1611 0x1011a0fa, 0x14d0bd4d, 0x19939b94, 0x1d528623, 1612 0xf12f560e, 0xf5ee4bb9, 0xf8ad6d60, 0xfc6c70d7, 1613 0xe22b20d2, 0xe6ea3d65, 0xeba91bbc, 0xef68060b, 1614 0xd727bbb6, 0xd3e6a601, 0xdea580d8, 0xda649d6f, 1615 0xc423cd6a, 0xc0e2d0dd, 0xcda1f604, 0xc960ebb3, 1616 0xbd3e8d7e, 0xb9ff90c9, 0xb4bcb610, 0xb07daba7, 1617 0xae3afba2, 0xaafbe615, 0xa7b8c0cc, 0xa379dd7b, 1618 0x9b3660c6, 0x9ff77d71, 0x92b45ba8, 0x9675461f, 1619 0x8832161a, 0x8cf30bad, 0x81b02d74, 0x857130c3, 1620 0x5d8a9099, 0x594b8d2e, 0x5408abf7, 0x50c9b640, 1621 0x4e8ee645, 0x4a4ffbf2, 0x470cdd2b, 0x43cdc09c, 1622 0x7b827d21, 0x7f436096, 0x7200464f, 0x76c15bf8, 1623 0x68860bfd, 0x6c47164a, 0x61043093, 0x65c52d24, 1624 0x119b4be9, 0x155a565e, 0x18197087, 0x1cd86d30, 1625 0x029f3d35, 0x065e2082, 0x0b1d065b, 0x0fdc1bec, 1626 0x3793a651, 0x3352bbe6, 0x3e119d3f, 0x3ad08088, 1627 0x2497d08d, 0x2056cd3a, 0x2d15ebe3, 0x29d4f654, 1628 0xc5a92679, 0xc1683bce, 0xcc2b1d17, 0xc8ea00a0, 1629 0xd6ad50a5, 0xd26c4d12, 0xdf2f6bcb, 0xdbee767c, 1630 0xe3a1cbc1, 0xe760d676, 0xea23f0af, 0xeee2ed18, 1631 0xf0a5bd1d, 0xf464a0aa, 0xf9278673, 0xfde69bc4, 1632 0x89b8fd09, 0x8d79e0be, 0x803ac667, 0x84fbdbd0, 1633 0x9abc8bd5, 0x9e7d9662, 0x933eb0bb, 0x97ffad0c, 1634 0xafb010b1, 0xab710d06, 0xa6322bdf, 0xa2f33668, 1635 0xbcb4666d, 0xb8757bda, 0xb5365d03, 0xb1f740b4 1636 }; 1637 1638 ATSParser::PSISection::PSISection() : 1639 mSkipBytes(0) { 1640 } 1641 1642 ATSParser::PSISection::~PSISection() { 1643 } 1644 1645 status_t ATSParser::PSISection::append(const void *data, size_t size) { 1646 if (mBuffer == NULL || mBuffer->size() + size > mBuffer->capacity()) { 1647 size_t newCapacity = 1648 (mBuffer == NULL) ? size : mBuffer->capacity() + size; 1649 1650 newCapacity = (newCapacity + 1023) & ~1023; 1651 1652 sp<ABuffer> newBuffer = new ABuffer(newCapacity); 1653 1654 if (mBuffer != NULL) { 1655 memcpy(newBuffer->data(), mBuffer->data(), mBuffer->size()); 1656 newBuffer->setRange(0, mBuffer->size()); 1657 } else { 1658 newBuffer->setRange(0, 0); 1659 } 1660 1661 mBuffer = newBuffer; 1662 } 1663 1664 memcpy(mBuffer->data() + mBuffer->size(), data, size); 1665 mBuffer->setRange(0, mBuffer->size() + size); 1666 1667 return OK; 1668 } 1669 1670 void ATSParser::PSISection::setSkipBytes(uint8_t skip) { 1671 mSkipBytes = skip; 1672 } 1673 1674 void ATSParser::PSISection::clear() { 1675 if (mBuffer != NULL) { 1676 mBuffer->setRange(0, 0); 1677 } 1678 mSkipBytes = 0; 1679 } 1680 1681 bool ATSParser::PSISection::isComplete() const { 1682 if (mBuffer == NULL || mBuffer->size() < 3) { 1683 return false; 1684 } 1685 1686 unsigned sectionLength = U16_AT(mBuffer->data() + 1) & 0xfff; 1687 return mBuffer->size() >= sectionLength + 3; 1688 } 1689 1690 bool ATSParser::PSISection::isEmpty() const { 1691 return mBuffer == NULL || mBuffer->size() == 0; 1692 } 1693 1694 const uint8_t *ATSParser::PSISection::data() const { 1695 return mBuffer == NULL ? NULL : mBuffer->data(); 1696 } 1697 1698 size_t ATSParser::PSISection::size() const { 1699 return mBuffer == NULL ? 0 : mBuffer->size(); 1700 } 1701 1702 bool ATSParser::PSISection::isCRCOkay() const { 1703 if (!isComplete()) { 1704 return false; 1705 } 1706 uint8_t* data = mBuffer->data(); 1707 1708 // Return true if section_syntax_indicator says no section follows the field section_length. 1709 if ((data[1] & 0x80) == 0) { 1710 return true; 1711 } 1712 1713 unsigned sectionLength = U16_AT(data + 1) & 0xfff; 1714 ALOGV("sectionLength %u, skip %u", sectionLength, mSkipBytes); 1715 1716 // Skip the preceding field present when payload start indicator is on. 1717 sectionLength -= mSkipBytes; 1718 1719 uint32_t crc = 0xffffffff; 1720 for(unsigned i = 0; i < sectionLength + 4 /* crc */; i++) { 1721 uint8_t b = data[i]; 1722 int index = ((crc >> 24) ^ (b & 0xff)) & 0xff; 1723 crc = CRC_TABLE[index] ^ (crc << 8); 1724 } 1725 ALOGV("crc: %08x\n", crc); 1726 return (crc == 0); 1727 } 1728 } // namespace android 1729
