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 #include "ATSParser.h" 21 #include "AnotherPacketSource.h" 22 #include "CasManager.h" 23 #include "ESQueue.h" 24 #include "include/avc_utils.h" 25 26 #include <android/hardware/cas/native/1.0/IDescrambler.h> 27 #include <cutils/native_handle.h> 28 #include <media/stagefright/foundation/ABitReader.h> 29 #include <media/stagefright/foundation/ABuffer.h> 30 #include <media/stagefright/foundation/ADebug.h> 31 #include <media/stagefright/foundation/AMessage.h> 32 #include <media/stagefright/foundation/hexdump.h> 33 #include <media/stagefright/MediaDefs.h> 34 #include <media/stagefright/MediaErrors.h> 35 #include <media/stagefright/MetaData.h> 36 #include <media/stagefright/Utils.h> 37 #include <media/IStreamSource.h> 38 #include <utils/KeyedVector.h> 39 #include <utils/Vector.h> 40 41 #include <inttypes.h> 42 43 namespace android { 44 using hardware::hidl_handle; 45 using hardware::hidl_memory; 46 using hardware::hidl_string; 47 using hardware::hidl_vec; 48 using namespace hardware::cas::V1_0; 49 using namespace hardware::cas::native::V1_0; 50 51 // I want the expression "y" evaluated even if verbose logging is off. 52 #define MY_LOGV(x, y) \ 53 do { unsigned tmp = y; ALOGV(x, tmp); } while (0) 54 55 static const size_t kTSPacketSize = 188; 56 57 struct ATSParser::Program : public RefBase { 58 Program(ATSParser *parser, unsigned programNumber, unsigned programMapPID, 59 int64_t lastRecoveredPTS); 60 61 bool parsePSISection( 62 unsigned pid, ABitReader *br, status_t *err); 63 64 // Pass to appropriate stream according to pid, and set event if it's a PES 65 // with a sync frame. 66 // Note that the method itself does not touch event. 67 bool parsePID( 68 unsigned pid, unsigned continuity_counter, 69 unsigned payload_unit_start_indicator, 70 unsigned transport_scrambling_control, 71 unsigned random_access_indicator, 72 ABitReader *br, status_t *err, SyncEvent *event); 73 74 void signalDiscontinuity( 75 DiscontinuityType type, const sp<AMessage> &extra); 76 77 void signalEOS(status_t finalResult); 78 79 sp<MediaSource> getSource(SourceType type); 80 bool hasSource(SourceType type) const; 81 82 int64_t convertPTSToTimestamp(uint64_t PTS); 83 84 bool PTSTimeDeltaEstablished() const { 85 return mFirstPTSValid; 86 } 87 88 unsigned number() const { return mProgramNumber; } 89 90 void updateProgramMapPID(unsigned programMapPID) { 91 mProgramMapPID = programMapPID; 92 } 93 94 unsigned programMapPID() const { 95 return mProgramMapPID; 96 } 97 98 uint32_t parserFlags() const { 99 return mParser->mFlags; 100 } 101 102 sp<CasManager> casManager() const { 103 return mParser->mCasManager; 104 } 105 106 uint64_t firstPTS() const { 107 return mFirstPTS; 108 } 109 110 void updateCasSessions(); 111 112 void signalNewSampleAesKey(const sp<AMessage> &keyItem); 113 114 private: 115 struct StreamInfo { 116 unsigned mType; 117 unsigned mPID; 118 int32_t mCASystemId; 119 }; 120 121 ATSParser *mParser; 122 unsigned mProgramNumber; 123 unsigned mProgramMapPID; 124 KeyedVector<unsigned, sp<Stream> > mStreams; 125 bool mFirstPTSValid; 126 uint64_t mFirstPTS; 127 int64_t mLastRecoveredPTS; 128 sp<AMessage> mSampleAesKeyItem; 129 130 status_t parseProgramMap(ABitReader *br); 131 int64_t recoverPTS(uint64_t PTS_33bit); 132 bool findCADescriptor( 133 ABitReader *br, unsigned infoLength, CADescriptor *caDescriptor); 134 bool switchPIDs(const Vector<StreamInfo> &infos); 135 136 DISALLOW_EVIL_CONSTRUCTORS(Program); 137 }; 138 139 struct ATSParser::Stream : public RefBase { 140 Stream(Program *program, 141 unsigned elementaryPID, 142 unsigned streamType, 143 unsigned PCR_PID, 144 int32_t CA_system_ID); 145 146 unsigned type() const { return mStreamType; } 147 unsigned pid() const { return mElementaryPID; } 148 void setPID(unsigned pid) { mElementaryPID = pid; } 149 150 void setCasInfo( 151 int32_t systemId, 152 const sp<IDescrambler> &descrambler, 153 const std::vector<uint8_t> &sessionId); 154 155 // Parse the payload and set event when PES with a sync frame is detected. 156 // This method knows when a PES starts; so record mPesStartOffsets in that 157 // case. 158 status_t parse( 159 unsigned continuity_counter, 160 unsigned payload_unit_start_indicator, 161 unsigned transport_scrambling_control, 162 unsigned random_access_indicator, 163 ABitReader *br, 164 SyncEvent *event); 165 166 void signalDiscontinuity( 167 DiscontinuityType type, const sp<AMessage> &extra); 168 169 void signalEOS(status_t finalResult); 170 171 SourceType getSourceType(); 172 sp<MediaSource> getSource(SourceType type); 173 174 bool isAudio() const; 175 bool isVideo() const; 176 bool isMeta() const; 177 178 void signalNewSampleAesKey(const sp<AMessage> &keyItem); 179 180 protected: 181 virtual ~Stream(); 182 183 private: 184 struct SubSampleInfo { 185 size_t subSampleSize; 186 unsigned transport_scrambling_mode; 187 unsigned random_access_indicator; 188 }; 189 Program *mProgram; 190 unsigned mElementaryPID; 191 unsigned mStreamType; 192 unsigned mPCR_PID; 193 int32_t mExpectedContinuityCounter; 194 195 sp<ABuffer> mBuffer; 196 sp<AnotherPacketSource> mSource; 197 bool mPayloadStarted; 198 bool mEOSReached; 199 200 uint64_t mPrevPTS; 201 List<off64_t> mPesStartOffsets; 202 203 ElementaryStreamQueue *mQueue; 204 205 bool mScrambled; 206 bool mSampleEncrypted; 207 sp<AMessage> mSampleAesKeyItem; 208 sp<IMemory> mMem; 209 sp<MemoryDealer> mDealer; 210 hardware::cas::native::V1_0::SharedBuffer mDescramblerSrcBuffer; 211 sp<ABuffer> mDescrambledBuffer; 212 List<SubSampleInfo> mSubSamples; 213 sp<IDescrambler> mDescrambler; 214 215 // Flush accumulated payload if necessary --- i.e. at EOS or at the start of 216 // another payload. event is set if the flushed payload is PES with a sync 217 // frame. 218 status_t flush(SyncEvent *event); 219 220 // Flush accumulated payload for scrambled streams if necessary --- i.e. at 221 // EOS or at the start of another payload. event is set if the flushed 222 // payload is PES with a sync frame. 223 status_t flushScrambled(SyncEvent *event); 224 225 // Check if a PES packet is scrambled at PES level. 226 uint32_t getPesScramblingControl(ABitReader *br, int32_t *pesOffset); 227 228 // Strip and parse PES headers and pass remaining payload into onPayload 229 // with parsed metadata. event is set if the PES contains a sync frame. 230 status_t parsePES(ABitReader *br, SyncEvent *event); 231 232 // Feed the payload into mQueue and if a packet is identified, queue it 233 // into mSource. If the packet is a sync frame. set event with start offset 234 // and timestamp of the packet. 235 void onPayloadData( 236 unsigned PTS_DTS_flags, uint64_t PTS, uint64_t DTS, 237 unsigned PES_scrambling_control, 238 const uint8_t *data, size_t size, 239 int32_t payloadOffset, SyncEvent *event); 240 241 // Ensure internal buffers can hold specified size, and will re-allocate 242 // as needed. 243 bool ensureBufferCapacity(size_t size); 244 245 DISALLOW_EVIL_CONSTRUCTORS(Stream); 246 }; 247 248 struct ATSParser::PSISection : public RefBase { 249 PSISection(); 250 251 status_t append(const void *data, size_t size); 252 void setSkipBytes(uint8_t skip); 253 void clear(); 254 255 bool isComplete() const; 256 bool isEmpty() const; 257 bool isCRCOkay() const; 258 259 const uint8_t *data() const; 260 size_t size() const; 261 262 protected: 263 virtual ~PSISection(); 264 265 private: 266 sp<ABuffer> mBuffer; 267 uint8_t mSkipBytes; 268 static uint32_t CRC_TABLE[]; 269 270 DISALLOW_EVIL_CONSTRUCTORS(PSISection); 271 }; 272 273 ATSParser::SyncEvent::SyncEvent(off64_t offset) 274 : mHasReturnedData(false), mOffset(offset), mTimeUs(0) {} 275 276 void ATSParser::SyncEvent::init(off64_t offset, const sp<MediaSource> &source, 277 int64_t timeUs, SourceType type) { 278 mHasReturnedData = true; 279 mOffset = offset; 280 mMediaSource = source; 281 mTimeUs = timeUs; 282 mType = type; 283 } 284 285 void ATSParser::SyncEvent::reset() { 286 mHasReturnedData = false; 287 } 288 //////////////////////////////////////////////////////////////////////////////// 289 290 ATSParser::Program::Program( 291 ATSParser *parser, unsigned programNumber, unsigned programMapPID, 292 int64_t lastRecoveredPTS) 293 : mParser(parser), 294 mProgramNumber(programNumber), 295 mProgramMapPID(programMapPID), 296 mFirstPTSValid(false), 297 mFirstPTS(0), 298 mLastRecoveredPTS(lastRecoveredPTS) { 299 ALOGV("new program number %u", programNumber); 300 } 301 302 bool ATSParser::Program::parsePSISection( 303 unsigned pid, ABitReader *br, status_t *err) { 304 *err = OK; 305 306 if (pid != mProgramMapPID) { 307 return false; 308 } 309 310 *err = parseProgramMap(br); 311 312 return true; 313 } 314 315 bool ATSParser::Program::parsePID( 316 unsigned pid, unsigned continuity_counter, 317 unsigned payload_unit_start_indicator, 318 unsigned transport_scrambling_control, 319 unsigned random_access_indicator, 320 ABitReader *br, status_t *err, SyncEvent *event) { 321 *err = OK; 322 323 ssize_t index = mStreams.indexOfKey(pid); 324 if (index < 0) { 325 return false; 326 } 327 328 *err = mStreams.editValueAt(index)->parse( 329 continuity_counter, 330 payload_unit_start_indicator, 331 transport_scrambling_control, 332 random_access_indicator, 333 br, event); 334 335 return true; 336 } 337 338 void ATSParser::Program::signalDiscontinuity( 339 DiscontinuityType type, const sp<AMessage> &extra) { 340 int64_t mediaTimeUs; 341 if ((type & DISCONTINUITY_TIME) 342 && extra != NULL 343 && extra->findInt64( 344 IStreamListener::kKeyMediaTimeUs, &mediaTimeUs)) { 345 mFirstPTSValid = false; 346 } 347 348 for (size_t i = 0; i < mStreams.size(); ++i) { 349 mStreams.editValueAt(i)->signalDiscontinuity(type, extra); 350 } 351 } 352 353 void ATSParser::Program::signalEOS(status_t finalResult) { 354 for (size_t i = 0; i < mStreams.size(); ++i) { 355 mStreams.editValueAt(i)->signalEOS(finalResult); 356 } 357 } 358 359 bool ATSParser::Program::switchPIDs(const Vector<StreamInfo> &infos) { 360 bool success = false; 361 362 if (mStreams.size() == infos.size()) { 363 // build type->PIDs map for old and new mapping 364 size_t i; 365 KeyedVector<int32_t, Vector<int32_t> > oldType2PIDs, newType2PIDs; 366 for (i = 0; i < mStreams.size(); ++i) { 367 ssize_t index = oldType2PIDs.indexOfKey(mStreams[i]->type()); 368 if (index < 0) { 369 oldType2PIDs.add(mStreams[i]->type(), Vector<int32_t>()); 370 } 371 oldType2PIDs.editValueFor(mStreams[i]->type()).push_back(mStreams[i]->pid()); 372 } 373 for (i = 0; i < infos.size(); ++i) { 374 ssize_t index = newType2PIDs.indexOfKey(infos[i].mType); 375 if (index < 0) { 376 newType2PIDs.add(infos[i].mType, Vector<int32_t>()); 377 } 378 newType2PIDs.editValueFor(infos[i].mType).push_back(infos[i].mPID); 379 } 380 381 // we can recover if the number of streams for each type hasn't changed 382 if (oldType2PIDs.size() == newType2PIDs.size()) { 383 success = true; 384 for (i = 0; i < oldType2PIDs.size(); ++i) { 385 // KeyedVector is sorted, we just compare key and size of each index 386 if (oldType2PIDs.keyAt(i) != newType2PIDs.keyAt(i) 387 || oldType2PIDs[i].size() != newType2PIDs[i].size()) { 388 success = false; 389 break; 390 } 391 } 392 } 393 394 if (success) { 395 // save current streams to temp 396 KeyedVector<int32_t, sp<Stream> > temp; 397 for (i = 0; i < mStreams.size(); ++i) { 398 temp.add(mStreams.keyAt(i), mStreams.editValueAt(i)); 399 } 400 401 mStreams.clear(); 402 for (i = 0; i < temp.size(); ++i) { 403 // The two checks below shouldn't happen, 404 // we already checked above the stream count matches 405 ssize_t index = newType2PIDs.indexOfKey(temp[i]->type()); 406 if (index < 0) { 407 return false; 408 } 409 Vector<int32_t> &newPIDs = newType2PIDs.editValueAt(index); 410 if (newPIDs.isEmpty()) { 411 return false; 412 } 413 414 // get the next PID for temp[i]->type() in the new PID map 415 Vector<int32_t>::iterator it = newPIDs.begin(); 416 417 // change the PID of the stream, and add it back 418 temp.editValueAt(i)->setPID(*it); 419 mStreams.add(temp[i]->pid(), temp.editValueAt(i)); 420 421 // removed the used PID 422 newPIDs.erase(it); 423 } 424 } 425 } 426 return success; 427 } 428 429 bool ATSParser::Program::findCADescriptor( 430 ABitReader *br, unsigned infoLength, 431 ATSParser::CADescriptor *caDescriptor) { 432 bool found = false; 433 while (infoLength > 2) { 434 unsigned descriptor_tag = br->getBits(8); 435 ALOGV(" tag = 0x%02x", descriptor_tag); 436 437 unsigned descriptor_length = br->getBits(8); 438 ALOGV(" len = %u", descriptor_length); 439 440 infoLength -= 2; 441 if (descriptor_length > infoLength) { 442 break; 443 } 444 if (descriptor_tag == 9 && descriptor_length >= 4) { 445 found = true; 446 caDescriptor->mSystemID = br->getBits(16); 447 caDescriptor->mPID = br->getBits(16) & 0x1fff; 448 infoLength -= 4; 449 caDescriptor->mPrivateData.assign( 450 br->data(), br->data() + descriptor_length - 4); 451 break; 452 } else { 453 infoLength -= descriptor_length; 454 br->skipBits(descriptor_length * 8); 455 } 456 } 457 br->skipBits(infoLength * 8); 458 return found; 459 } 460 461 status_t ATSParser::Program::parseProgramMap(ABitReader *br) { 462 unsigned table_id = br->getBits(8); 463 ALOGV(" table_id = %u", table_id); 464 if (table_id != 0x02u) { 465 ALOGE("PMT data error!"); 466 return ERROR_MALFORMED; 467 } 468 unsigned section_syntax_indicator = br->getBits(1); 469 ALOGV(" section_syntax_indicator = %u", section_syntax_indicator); 470 if (section_syntax_indicator != 1u) { 471 ALOGE("PMT data error!"); 472 return ERROR_MALFORMED; 473 } 474 475 br->skipBits(1); // '0' 476 MY_LOGV(" reserved = %u", br->getBits(2)); 477 478 unsigned section_length = br->getBits(12); 479 ALOGV(" section_length = %u", section_length); 480 481 MY_LOGV(" program_number = %u", br->getBits(16)); 482 MY_LOGV(" reserved = %u", br->getBits(2)); 483 MY_LOGV(" version_number = %u", br->getBits(5)); 484 MY_LOGV(" current_next_indicator = %u", br->getBits(1)); 485 MY_LOGV(" section_number = %u", br->getBits(8)); 486 MY_LOGV(" last_section_number = %u", br->getBits(8)); 487 MY_LOGV(" reserved = %u", br->getBits(3)); 488 489 unsigned PCR_PID = br->getBits(13); 490 ALOGV(" PCR_PID = 0x%04x", PCR_PID); 491 492 MY_LOGV(" reserved = %u", br->getBits(4)); 493 494 unsigned program_info_length = br->getBits(12); 495 ALOGV(" program_info_length = %u", program_info_length); 496 497 // descriptors 498 CADescriptor programCA; 499 bool hasProgramCA = findCADescriptor(br, program_info_length, &programCA); 500 if (hasProgramCA && !mParser->mCasManager->addProgram( 501 mProgramNumber, programCA)) { 502 return ERROR_MALFORMED; 503 } 504 505 Vector<StreamInfo> infos; 506 507 // infoBytesRemaining is the number of bytes that make up the 508 // variable length section of ES_infos. It does not include the 509 // final CRC. 510 size_t infoBytesRemaining = section_length - 9 - program_info_length - 4; 511 512 while (infoBytesRemaining >= 5) { 513 514 unsigned streamType = br->getBits(8); 515 ALOGV(" stream_type = 0x%02x", streamType); 516 517 MY_LOGV(" reserved = %u", br->getBits(3)); 518 519 unsigned elementaryPID = br->getBits(13); 520 ALOGV(" elementary_PID = 0x%04x", elementaryPID); 521 522 MY_LOGV(" reserved = %u", br->getBits(4)); 523 524 unsigned ES_info_length = br->getBits(12); 525 ALOGV(" ES_info_length = %u", ES_info_length); 526 527 CADescriptor streamCA; 528 bool hasStreamCA = findCADescriptor(br, ES_info_length, &streamCA); 529 if (hasStreamCA && !mParser->mCasManager->addStream( 530 mProgramNumber, elementaryPID, streamCA)) { 531 return ERROR_MALFORMED; 532 } 533 StreamInfo info; 534 info.mType = streamType; 535 info.mPID = elementaryPID; 536 info.mCASystemId = hasProgramCA ? programCA.mSystemID : 537 hasStreamCA ? streamCA.mSystemID : -1; 538 infos.push(info); 539 540 infoBytesRemaining -= 5 + ES_info_length; 541 } 542 543 if (infoBytesRemaining != 0) { 544 ALOGW("Section data remains unconsumed"); 545 } 546 MY_LOGV(" CRC = 0x%08x", br->getBits(32)); 547 548 bool PIDsChanged = false; 549 for (size_t i = 0; i < infos.size(); ++i) { 550 StreamInfo &info = infos.editItemAt(i); 551 552 ssize_t index = mStreams.indexOfKey(info.mPID); 553 554 if (index >= 0 && mStreams.editValueAt(index)->type() != info.mType) { 555 ALOGI("uh oh. stream PIDs have changed."); 556 PIDsChanged = true; 557 break; 558 } 559 } 560 561 if (PIDsChanged) { 562 #if 0 563 ALOGI("before:"); 564 for (size_t i = 0; i < mStreams.size(); ++i) { 565 sp<Stream> stream = mStreams.editValueAt(i); 566 567 ALOGI("PID 0x%08x => type 0x%02x", stream->pid(), stream->type()); 568 } 569 570 ALOGI("after:"); 571 for (size_t i = 0; i < infos.size(); ++i) { 572 StreamInfo &info = infos.editItemAt(i); 573 574 ALOGI("PID 0x%08x => type 0x%02x", info.mPID, info.mType); 575 } 576 #endif 577 578 // we can recover if number of streams for each type remain the same 579 bool success = switchPIDs(infos); 580 581 if (!success) { 582 ALOGI("Stream PIDs changed and we cannot recover."); 583 return ERROR_MALFORMED; 584 } 585 } 586 587 bool isAddingScrambledStream = false; 588 for (size_t i = 0; i < infos.size(); ++i) { 589 StreamInfo &info = infos.editItemAt(i); 590 591 if (mParser->mCasManager->isCAPid(info.mPID)) { 592 // skip CA streams (EMM/ECM) 593 continue; 594 } 595 ssize_t index = mStreams.indexOfKey(info.mPID); 596 597 if (index < 0) { 598 sp<Stream> stream = new Stream( 599 this, info.mPID, info.mType, PCR_PID, info.mCASystemId); 600 601 if (mSampleAesKeyItem != NULL) { 602 stream->signalNewSampleAesKey(mSampleAesKeyItem); 603 } 604 605 isAddingScrambledStream |= info.mCASystemId >= 0; 606 mStreams.add(info.mPID, stream); 607 } 608 } 609 610 if (isAddingScrambledStream) { 611 ALOGI("Receiving scrambled streams without descrambler!"); 612 return ERROR_DRM_DECRYPT_UNIT_NOT_INITIALIZED; 613 } 614 return OK; 615 } 616 617 int64_t ATSParser::Program::recoverPTS(uint64_t PTS_33bit) { 618 // We only have the lower 33-bit of the PTS. It could overflow within a 619 // reasonable amount of time. To handle the wrap-around, use fancy math 620 // to get an extended PTS that is within [-0xffffffff, 0xffffffff] 621 // of the latest recovered PTS. 622 if (mLastRecoveredPTS < 0ll) { 623 // Use the original 33bit number for 1st frame, the reason is that 624 // if 1st frame wraps to negative that's far away from 0, we could 625 // never start. Only start wrapping around from 2nd frame. 626 mLastRecoveredPTS = static_cast<int64_t>(PTS_33bit); 627 } else { 628 mLastRecoveredPTS = static_cast<int64_t>( 629 ((mLastRecoveredPTS - static_cast<int64_t>(PTS_33bit) + 0x100000000ll) 630 & 0xfffffffe00000000ull) | PTS_33bit); 631 // We start from 0, but recovered PTS could be slightly below 0. 632 // Clamp it to 0 as rest of the pipeline doesn't take negative pts. 633 // (eg. video is read first and starts at 0, but audio starts at 0xfffffff0) 634 if (mLastRecoveredPTS < 0ll) { 635 ALOGI("Clamping negative recovered PTS (%" PRId64 ") to 0", mLastRecoveredPTS); 636 mLastRecoveredPTS = 0ll; 637 } 638 } 639 640 return mLastRecoveredPTS; 641 } 642 643 sp<MediaSource> ATSParser::Program::getSource(SourceType type) { 644 for (size_t i = 0; i < mStreams.size(); ++i) { 645 sp<MediaSource> source = mStreams.editValueAt(i)->getSource(type); 646 if (source != NULL) { 647 return source; 648 } 649 } 650 651 return NULL; 652 } 653 654 bool ATSParser::Program::hasSource(SourceType type) const { 655 for (size_t i = 0; i < mStreams.size(); ++i) { 656 const sp<Stream> &stream = mStreams.valueAt(i); 657 if (type == AUDIO && stream->isAudio()) { 658 return true; 659 } else if (type == VIDEO && stream->isVideo()) { 660 return true; 661 } else if (type == META && stream->isMeta()) { 662 return true; 663 } 664 } 665 666 return false; 667 } 668 669 int64_t ATSParser::Program::convertPTSToTimestamp(uint64_t PTS) { 670 PTS = recoverPTS(PTS); 671 672 if (!(mParser->mFlags & TS_TIMESTAMPS_ARE_ABSOLUTE)) { 673 if (!mFirstPTSValid) { 674 mFirstPTSValid = true; 675 mFirstPTS = PTS; 676 PTS = 0; 677 } else if (PTS < mFirstPTS) { 678 PTS = 0; 679 } else { 680 PTS -= mFirstPTS; 681 } 682 } 683 684 int64_t timeUs = (PTS * 100) / 9; 685 686 if (mParser->mAbsoluteTimeAnchorUs >= 0ll) { 687 timeUs += mParser->mAbsoluteTimeAnchorUs; 688 } 689 690 if (mParser->mTimeOffsetValid) { 691 timeUs += mParser->mTimeOffsetUs; 692 } 693 694 return timeUs; 695 } 696 697 void ATSParser::Program::updateCasSessions() { 698 for (size_t i = 0; i < mStreams.size(); ++i) { 699 sp<Stream> &stream = mStreams.editValueAt(i); 700 sp<IDescrambler> descrambler; 701 std::vector<uint8_t> sessionId; 702 int32_t systemId; 703 if (mParser->mCasManager->getCasInfo(mProgramNumber, stream->pid(), 704 &systemId, &descrambler, &sessionId)) { 705 stream->setCasInfo(systemId, descrambler, sessionId); 706 } 707 } 708 } 709 710 //////////////////////////////////////////////////////////////////////////////// 711 static const size_t kInitialStreamBufferSize = 192 * 1024; 712 713 ATSParser::Stream::Stream( 714 Program *program, 715 unsigned elementaryPID, 716 unsigned streamType, 717 unsigned PCR_PID, 718 int32_t CA_system_ID) 719 : mProgram(program), 720 mElementaryPID(elementaryPID), 721 mStreamType(streamType), 722 mPCR_PID(PCR_PID), 723 mExpectedContinuityCounter(-1), 724 mPayloadStarted(false), 725 mEOSReached(false), 726 mPrevPTS(0), 727 mQueue(NULL), 728 mScrambled(CA_system_ID >= 0) { 729 730 mSampleEncrypted = 731 mStreamType == STREAMTYPE_H264_ENCRYPTED || 732 mStreamType == STREAMTYPE_AAC_ENCRYPTED || 733 mStreamType == STREAMTYPE_AC3_ENCRYPTED; 734 735 ALOGV("new stream PID 0x%02x, type 0x%02x, scrambled %d, SampleEncrypted: %d", 736 elementaryPID, streamType, mScrambled, mSampleEncrypted); 737 738 uint32_t flags = 739 (isVideo() && mScrambled) ? ElementaryStreamQueue::kFlag_ScrambledData : 740 (mSampleEncrypted) ? ElementaryStreamQueue::kFlag_SampleEncryptedData : 741 0; 742 743 ElementaryStreamQueue::Mode mode = ElementaryStreamQueue::INVALID; 744 745 switch (mStreamType) { 746 case STREAMTYPE_H264: 747 case STREAMTYPE_H264_ENCRYPTED: 748 mode = ElementaryStreamQueue::H264; 749 flags |= (mProgram->parserFlags() & ALIGNED_VIDEO_DATA) ? 750 ElementaryStreamQueue::kFlag_AlignedData : 0; 751 break; 752 753 case STREAMTYPE_MPEG2_AUDIO_ADTS: 754 case STREAMTYPE_AAC_ENCRYPTED: 755 mode = ElementaryStreamQueue::AAC; 756 break; 757 758 case STREAMTYPE_MPEG1_AUDIO: 759 case STREAMTYPE_MPEG2_AUDIO: 760 mode = ElementaryStreamQueue::MPEG_AUDIO; 761 break; 762 763 case STREAMTYPE_MPEG1_VIDEO: 764 case STREAMTYPE_MPEG2_VIDEO: 765 mode = ElementaryStreamQueue::MPEG_VIDEO; 766 break; 767 768 case STREAMTYPE_MPEG4_VIDEO: 769 mode = ElementaryStreamQueue::MPEG4_VIDEO; 770 break; 771 772 case STREAMTYPE_LPCM_AC3: 773 case STREAMTYPE_AC3: 774 case STREAMTYPE_AC3_ENCRYPTED: 775 mode = ElementaryStreamQueue::AC3; 776 break; 777 778 case STREAMTYPE_METADATA: 779 mode = ElementaryStreamQueue::METADATA; 780 break; 781 782 default: 783 ALOGE("stream PID 0x%02x has invalid stream type 0x%02x", 784 elementaryPID, streamType); 785 return; 786 } 787 788 mQueue = new ElementaryStreamQueue(mode, flags); 789 790 if (mQueue != NULL) { 791 if (mSampleAesKeyItem != NULL) { 792 mQueue->signalNewSampleAesKey(mSampleAesKeyItem); 793 } 794 795 ensureBufferCapacity(kInitialStreamBufferSize); 796 797 if (mScrambled && (isAudio() || isVideo())) { 798 // Set initial format to scrambled 799 sp<MetaData> meta = new MetaData(); 800 meta->setCString(kKeyMIMEType, 801 isAudio() ? MEDIA_MIMETYPE_AUDIO_SCRAMBLED 802 : MEDIA_MIMETYPE_VIDEO_SCRAMBLED); 803 // for MediaExtractor.CasInfo 804 meta->setInt32(kKeyCASystemID, CA_system_ID); 805 mSource = new AnotherPacketSource(meta); 806 } 807 } 808 } 809 810 ATSParser::Stream::~Stream() { 811 delete mQueue; 812 mQueue = NULL; 813 } 814 815 bool ATSParser::Stream::ensureBufferCapacity(size_t neededSize) { 816 if (mBuffer != NULL && mBuffer->capacity() >= neededSize) { 817 return true; 818 } 819 820 ALOGV("ensureBufferCapacity: current size %zu, new size %zu, scrambled %d", 821 mBuffer == NULL ? 0 : mBuffer->capacity(), neededSize, mScrambled); 822 823 sp<ABuffer> newBuffer, newScrambledBuffer; 824 sp<IMemory> newMem; 825 sp<MemoryDealer> newDealer; 826 if (mScrambled) { 827 size_t alignment = MemoryDealer::getAllocationAlignment(); 828 neededSize = (neededSize + (alignment - 1)) & ~(alignment - 1); 829 // Align to multiples of 64K. 830 neededSize = (neededSize + 65535) & ~65535; 831 newDealer = new MemoryDealer(neededSize, "ATSParser"); 832 newMem = newDealer->allocate(neededSize); 833 newScrambledBuffer = new ABuffer(newMem->pointer(), newMem->size()); 834 835 if (mDescrambledBuffer != NULL) { 836 memcpy(newScrambledBuffer->data(), 837 mDescrambledBuffer->data(), mDescrambledBuffer->size()); 838 newScrambledBuffer->setRange(0, mDescrambledBuffer->size()); 839 } else { 840 newScrambledBuffer->setRange(0, 0); 841 } 842 mMem = newMem; 843 mDealer = newDealer; 844 mDescrambledBuffer = newScrambledBuffer; 845 846 ssize_t offset; 847 size_t size; 848 sp<IMemoryHeap> heap = newMem->getMemory(&offset, &size); 849 if (heap == NULL) { 850 return false; 851 } 852 native_handle_t* nativeHandle = native_handle_create(1, 0); 853 if (!nativeHandle) { 854 ALOGE("[stream %d] failed to create native handle", mElementaryPID); 855 return false; 856 } 857 nativeHandle->data[0] = heap->getHeapID(); 858 mDescramblerSrcBuffer.heapBase = hidl_memory("ashmem", 859 hidl_handle(nativeHandle), heap->getSize()); 860 mDescramblerSrcBuffer.offset = (uint64_t) offset; 861 mDescramblerSrcBuffer.size = (uint64_t) size; 862 863 ALOGD("[stream %d] created shared buffer for descrambling, offset %zd, size %zu", 864 mElementaryPID, offset, size); 865 } else { 866 // Align to multiples of 64K. 867 neededSize = (neededSize + 65535) & ~65535; 868 } 869 870 newBuffer = new ABuffer(neededSize); 871 if (mBuffer != NULL) { 872 memcpy(newBuffer->data(), mBuffer->data(), mBuffer->size()); 873 newBuffer->setRange(0, mBuffer->size()); 874 } else { 875 newBuffer->setRange(0, 0); 876 } 877 mBuffer = newBuffer; 878 return true; 879 } 880 881 status_t ATSParser::Stream::parse( 882 unsigned continuity_counter, 883 unsigned payload_unit_start_indicator, 884 unsigned transport_scrambling_control, 885 unsigned random_access_indicator, 886 ABitReader *br, SyncEvent *event) { 887 if (mQueue == NULL) { 888 return OK; 889 } 890 891 if (mExpectedContinuityCounter >= 0 892 && (unsigned)mExpectedContinuityCounter != continuity_counter) { 893 ALOGI("discontinuity on stream pid 0x%04x", mElementaryPID); 894 895 mPayloadStarted = false; 896 mPesStartOffsets.clear(); 897 mBuffer->setRange(0, 0); 898 mSubSamples.clear(); 899 mExpectedContinuityCounter = -1; 900 901 #if 0 902 // Uncomment this if you'd rather see no corruption whatsoever on 903 // screen and suspend updates until we come across another IDR frame. 904 905 if (mStreamType == STREAMTYPE_H264) { 906 ALOGI("clearing video queue"); 907 mQueue->clear(true /* clearFormat */); 908 } 909 #endif 910 911 if (!payload_unit_start_indicator) { 912 return OK; 913 } 914 } 915 916 mExpectedContinuityCounter = (continuity_counter + 1) & 0x0f; 917 918 if (payload_unit_start_indicator) { 919 off64_t offset = (event != NULL) ? event->getOffset() : 0; 920 if (mPayloadStarted) { 921 // Otherwise we run the danger of receiving the trailing bytes 922 // of a PES packet that we never saw the start of and assuming 923 // we have a a complete PES packet. 924 925 status_t err = flush(event); 926 927 if (err != OK) { 928 ALOGW("Error (%08x) happened while flushing; we simply discard " 929 "the PES packet and continue.", err); 930 } 931 } 932 933 mPayloadStarted = true; 934 // There should be at most 2 elements in |mPesStartOffsets|. 935 while (mPesStartOffsets.size() >= 2) { 936 mPesStartOffsets.erase(mPesStartOffsets.begin()); 937 } 938 mPesStartOffsets.push_back(offset); 939 } 940 941 if (!mPayloadStarted) { 942 return OK; 943 } 944 945 size_t payloadSizeBits = br->numBitsLeft(); 946 if (payloadSizeBits % 8 != 0u) { 947 ALOGE("Wrong value"); 948 return BAD_VALUE; 949 } 950 951 size_t neededSize = mBuffer->size() + payloadSizeBits / 8; 952 if (!ensureBufferCapacity(neededSize)) { 953 return NO_MEMORY; 954 } 955 956 memcpy(mBuffer->data() + mBuffer->size(), br->data(), payloadSizeBits / 8); 957 mBuffer->setRange(0, mBuffer->size() + payloadSizeBits / 8); 958 959 if (mScrambled) { 960 mSubSamples.push_back({payloadSizeBits / 8, 961 transport_scrambling_control, random_access_indicator}); 962 } 963 964 return OK; 965 } 966 967 bool ATSParser::Stream::isVideo() const { 968 switch (mStreamType) { 969 case STREAMTYPE_H264: 970 case STREAMTYPE_H264_ENCRYPTED: 971 case STREAMTYPE_MPEG1_VIDEO: 972 case STREAMTYPE_MPEG2_VIDEO: 973 case STREAMTYPE_MPEG4_VIDEO: 974 return true; 975 976 default: 977 return false; 978 } 979 } 980 981 bool ATSParser::Stream::isAudio() const { 982 switch (mStreamType) { 983 case STREAMTYPE_MPEG1_AUDIO: 984 case STREAMTYPE_MPEG2_AUDIO: 985 case STREAMTYPE_MPEG2_AUDIO_ADTS: 986 case STREAMTYPE_LPCM_AC3: 987 case STREAMTYPE_AC3: 988 case STREAMTYPE_AAC_ENCRYPTED: 989 case STREAMTYPE_AC3_ENCRYPTED: 990 return true; 991 992 default: 993 return false; 994 } 995 } 996 997 bool ATSParser::Stream::isMeta() const { 998 if (mStreamType == STREAMTYPE_METADATA) { 999 return true; 1000 } 1001 return false; 1002 } 1003 1004 void ATSParser::Stream::signalDiscontinuity( 1005 DiscontinuityType type, const sp<AMessage> &extra) { 1006 mExpectedContinuityCounter = -1; 1007 1008 if (mQueue == NULL) { 1009 return; 1010 } 1011 1012 mPayloadStarted = false; 1013 mPesStartOffsets.clear(); 1014 mEOSReached = false; 1015 mBuffer->setRange(0, 0); 1016 mSubSamples.clear(); 1017 1018 bool clearFormat = false; 1019 if (isAudio()) { 1020 if (type & DISCONTINUITY_AUDIO_FORMAT) { 1021 clearFormat = true; 1022 } 1023 } else { 1024 if (type & DISCONTINUITY_VIDEO_FORMAT) { 1025 clearFormat = true; 1026 } 1027 } 1028 1029 mQueue->clear(clearFormat); 1030 1031 if (type & DISCONTINUITY_TIME) { 1032 uint64_t resumeAtPTS; 1033 if (extra != NULL 1034 && extra->findInt64( 1035 IStreamListener::kKeyResumeAtPTS, 1036 (int64_t *)&resumeAtPTS)) { 1037 int64_t resumeAtMediaTimeUs = 1038 mProgram->convertPTSToTimestamp(resumeAtPTS); 1039 1040 extra->setInt64("resume-at-mediaTimeUs", resumeAtMediaTimeUs); 1041 } 1042 } 1043 1044 if (mSource != NULL) { 1045 sp<MetaData> meta = mSource->getFormat(); 1046 const char* mime; 1047 if (clearFormat && meta != NULL && meta->findCString(kKeyMIMEType, &mime) 1048 && (!strncasecmp(mime, MEDIA_MIMETYPE_AUDIO_SCRAMBLED, 15) 1049 || !strncasecmp(mime, MEDIA_MIMETYPE_VIDEO_SCRAMBLED, 15))){ 1050 mSource->clear(); 1051 } else { 1052 mSource->queueDiscontinuity(type, extra, true); 1053 } 1054 } 1055 } 1056 1057 void ATSParser::Stream::signalEOS(status_t finalResult) { 1058 if (mSource != NULL) { 1059 mSource->signalEOS(finalResult); 1060 } 1061 mEOSReached = true; 1062 flush(NULL); 1063 } 1064 1065 status_t ATSParser::Stream::parsePES(ABitReader *br, SyncEvent *event) { 1066 const uint8_t *basePtr = br->data(); 1067 1068 unsigned packet_startcode_prefix = br->getBits(24); 1069 1070 ALOGV("packet_startcode_prefix = 0x%08x", packet_startcode_prefix); 1071 1072 if (packet_startcode_prefix != 1) { 1073 ALOGV("Supposedly payload_unit_start=1 unit does not start " 1074 "with startcode."); 1075 1076 return ERROR_MALFORMED; 1077 } 1078 1079 unsigned stream_id = br->getBits(8); 1080 ALOGV("stream_id = 0x%02x", stream_id); 1081 1082 unsigned PES_packet_length = br->getBits(16); 1083 ALOGV("PES_packet_length = %u", PES_packet_length); 1084 1085 if (stream_id != 0xbc // program_stream_map 1086 && stream_id != 0xbe // padding_stream 1087 && stream_id != 0xbf // private_stream_2 1088 && stream_id != 0xf0 // ECM 1089 && stream_id != 0xf1 // EMM 1090 && stream_id != 0xff // program_stream_directory 1091 && stream_id != 0xf2 // DSMCC 1092 && stream_id != 0xf8) { // H.222.1 type E 1093 if (br->getBits(2) != 2u) { 1094 return ERROR_MALFORMED; 1095 } 1096 1097 unsigned PES_scrambling_control = br->getBits(2); 1098 ALOGV("PES_scrambling_control = %u", PES_scrambling_control); 1099 1100 MY_LOGV("PES_priority = %u", br->getBits(1)); 1101 MY_LOGV("data_alignment_indicator = %u", br->getBits(1)); 1102 MY_LOGV("copyright = %u", br->getBits(1)); 1103 MY_LOGV("original_or_copy = %u", br->getBits(1)); 1104 1105 unsigned PTS_DTS_flags = br->getBits(2); 1106 ALOGV("PTS_DTS_flags = %u", PTS_DTS_flags); 1107 1108 unsigned ESCR_flag = br->getBits(1); 1109 ALOGV("ESCR_flag = %u", ESCR_flag); 1110 1111 unsigned ES_rate_flag = br->getBits(1); 1112 ALOGV("ES_rate_flag = %u", ES_rate_flag); 1113 1114 unsigned DSM_trick_mode_flag = br->getBits(1); 1115 ALOGV("DSM_trick_mode_flag = %u", DSM_trick_mode_flag); 1116 1117 unsigned additional_copy_info_flag = br->getBits(1); 1118 ALOGV("additional_copy_info_flag = %u", additional_copy_info_flag); 1119 1120 MY_LOGV("PES_CRC_flag = %u", br->getBits(1)); 1121 MY_LOGV("PES_extension_flag = %u", br->getBits(1)); 1122 1123 unsigned PES_header_data_length = br->getBits(8); 1124 ALOGV("PES_header_data_length = %u", PES_header_data_length); 1125 1126 unsigned optional_bytes_remaining = PES_header_data_length; 1127 1128 uint64_t PTS = 0, DTS = 0; 1129 1130 if (PTS_DTS_flags == 2 || PTS_DTS_flags == 3) { 1131 if (optional_bytes_remaining < 5u) { 1132 return ERROR_MALFORMED; 1133 } 1134 1135 if (br->getBits(4) != PTS_DTS_flags) { 1136 return ERROR_MALFORMED; 1137 } 1138 PTS = ((uint64_t)br->getBits(3)) << 30; 1139 if (br->getBits(1) != 1u) { 1140 return ERROR_MALFORMED; 1141 } 1142 PTS |= ((uint64_t)br->getBits(15)) << 15; 1143 if (br->getBits(1) != 1u) { 1144 return ERROR_MALFORMED; 1145 } 1146 PTS |= br->getBits(15); 1147 if (br->getBits(1) != 1u) { 1148 return ERROR_MALFORMED; 1149 } 1150 1151 ALOGV("PTS = 0x%016" PRIx64 " (%.2f)", PTS, PTS / 90000.0); 1152 1153 optional_bytes_remaining -= 5; 1154 1155 if (PTS_DTS_flags == 3) { 1156 if (optional_bytes_remaining < 5u) { 1157 return ERROR_MALFORMED; 1158 } 1159 1160 if (br->getBits(4) != 1u) { 1161 return ERROR_MALFORMED; 1162 } 1163 1164 DTS = ((uint64_t)br->getBits(3)) << 30; 1165 if (br->getBits(1) != 1u) { 1166 return ERROR_MALFORMED; 1167 } 1168 DTS |= ((uint64_t)br->getBits(15)) << 15; 1169 if (br->getBits(1) != 1u) { 1170 return ERROR_MALFORMED; 1171 } 1172 DTS |= br->getBits(15); 1173 if (br->getBits(1) != 1u) { 1174 return ERROR_MALFORMED; 1175 } 1176 1177 ALOGV("DTS = %" PRIu64, DTS); 1178 1179 optional_bytes_remaining -= 5; 1180 } 1181 } 1182 1183 if (ESCR_flag) { 1184 if (optional_bytes_remaining < 6u) { 1185 return ERROR_MALFORMED; 1186 } 1187 1188 br->getBits(2); 1189 1190 uint64_t ESCR = ((uint64_t)br->getBits(3)) << 30; 1191 if (br->getBits(1) != 1u) { 1192 return ERROR_MALFORMED; 1193 } 1194 ESCR |= ((uint64_t)br->getBits(15)) << 15; 1195 if (br->getBits(1) != 1u) { 1196 return ERROR_MALFORMED; 1197 } 1198 ESCR |= br->getBits(15); 1199 if (br->getBits(1) != 1u) { 1200 return ERROR_MALFORMED; 1201 } 1202 1203 ALOGV("ESCR = %" PRIu64, ESCR); 1204 MY_LOGV("ESCR_extension = %u", br->getBits(9)); 1205 1206 if (br->getBits(1) != 1u) { 1207 return ERROR_MALFORMED; 1208 } 1209 1210 optional_bytes_remaining -= 6; 1211 } 1212 1213 if (ES_rate_flag) { 1214 if (optional_bytes_remaining < 3u) { 1215 return ERROR_MALFORMED; 1216 } 1217 1218 if (br->getBits(1) != 1u) { 1219 return ERROR_MALFORMED; 1220 } 1221 MY_LOGV("ES_rate = %u", br->getBits(22)); 1222 if (br->getBits(1) != 1u) { 1223 return ERROR_MALFORMED; 1224 } 1225 1226 optional_bytes_remaining -= 3; 1227 } 1228 1229 br->skipBits(optional_bytes_remaining * 8); 1230 1231 // ES data follows. 1232 int32_t pesOffset = br->data() - basePtr; 1233 1234 if (PES_packet_length != 0) { 1235 if (PES_packet_length < PES_header_data_length + 3) { 1236 return ERROR_MALFORMED; 1237 } 1238 1239 unsigned dataLength = 1240 PES_packet_length - 3 - PES_header_data_length; 1241 1242 if (br->numBitsLeft() < dataLength * 8) { 1243 ALOGE("PES packet does not carry enough data to contain " 1244 "payload. (numBitsLeft = %zu, required = %u)", 1245 br->numBitsLeft(), dataLength * 8); 1246 1247 return ERROR_MALFORMED; 1248 } 1249 1250 ALOGV("There's %u bytes of payload, PES_packet_length=%u, offset=%d", 1251 dataLength, PES_packet_length, pesOffset); 1252 1253 onPayloadData( 1254 PTS_DTS_flags, PTS, DTS, PES_scrambling_control, 1255 br->data(), dataLength, pesOffset, event); 1256 1257 br->skipBits(dataLength * 8); 1258 } else { 1259 onPayloadData( 1260 PTS_DTS_flags, PTS, DTS, PES_scrambling_control, 1261 br->data(), br->numBitsLeft() / 8, pesOffset, event); 1262 1263 size_t payloadSizeBits = br->numBitsLeft(); 1264 if (payloadSizeBits % 8 != 0u) { 1265 return ERROR_MALFORMED; 1266 } 1267 1268 ALOGV("There's %zu bytes of payload, offset=%d", 1269 payloadSizeBits / 8, pesOffset); 1270 } 1271 } else if (stream_id == 0xbe) { // padding_stream 1272 if (PES_packet_length == 0u) { 1273 return ERROR_MALFORMED; 1274 } 1275 br->skipBits(PES_packet_length * 8); 1276 } else { 1277 if (PES_packet_length == 0u) { 1278 return ERROR_MALFORMED; 1279 } 1280 br->skipBits(PES_packet_length * 8); 1281 } 1282 1283 return OK; 1284 } 1285 1286 uint32_t ATSParser::Stream::getPesScramblingControl( 1287 ABitReader *br, int32_t *pesOffset) { 1288 unsigned packet_startcode_prefix = br->getBits(24); 1289 1290 ALOGV("packet_startcode_prefix = 0x%08x", packet_startcode_prefix); 1291 1292 if (packet_startcode_prefix != 1) { 1293 ALOGV("unit does not start with startcode."); 1294 return 0; 1295 } 1296 1297 if (br->numBitsLeft() < 48) { 1298 return 0; 1299 } 1300 1301 unsigned stream_id = br->getBits(8); 1302 ALOGV("stream_id = 0x%02x", stream_id); 1303 1304 br->skipBits(16); // PES_packet_length 1305 1306 if (stream_id != 0xbc // program_stream_map 1307 && stream_id != 0xbe // padding_stream 1308 && stream_id != 0xbf // private_stream_2 1309 && stream_id != 0xf0 // ECM 1310 && stream_id != 0xf1 // EMM 1311 && stream_id != 0xff // program_stream_directory 1312 && stream_id != 0xf2 // DSMCC 1313 && stream_id != 0xf8) { // H.222.1 type E 1314 if (br->getBits(2) != 2u) { 1315 return 0; 1316 } 1317 1318 unsigned PES_scrambling_control = br->getBits(2); 1319 ALOGV("PES_scrambling_control = %u", PES_scrambling_control); 1320 1321 if (PES_scrambling_control == 0) { 1322 return 0; 1323 } 1324 1325 br->skipBits(12); // don't care 1326 1327 unsigned PES_header_data_length = br->getBits(8); 1328 ALOGV("PES_header_data_length = %u", PES_header_data_length); 1329 1330 if (PES_header_data_length * 8 > br->numBitsLeft()) { 1331 return 0; 1332 } 1333 1334 *pesOffset = 9 + PES_header_data_length; 1335 ALOGD("found PES_scrambling_control=%d, PES offset=%d", 1336 PES_scrambling_control, *pesOffset); 1337 return PES_scrambling_control; 1338 } 1339 1340 return 0; 1341 } 1342 1343 status_t ATSParser::Stream::flushScrambled(SyncEvent *event) { 1344 if (mDescrambler == NULL) { 1345 ALOGE("received scrambled packets without descrambler!"); 1346 return UNKNOWN_ERROR; 1347 } 1348 1349 if (mDescrambledBuffer == NULL || mMem == NULL) { 1350 ALOGE("received scrambled packets without shared memory!"); 1351 1352 return UNKNOWN_ERROR; 1353 } 1354 1355 int32_t pesOffset = 0; 1356 int32_t descrambleSubSamples = 0, descrambleBytes = 0; 1357 uint32_t tsScramblingControl = 0, pesScramblingControl = 0; 1358 1359 // First, go over subsamples to find TS-level scrambling key id, and 1360 // calculate how many subsample we need to descramble (assuming we don't 1361 // have PES-level scrambling). 1362 for (auto it = mSubSamples.begin(); it != mSubSamples.end(); it++) { 1363 if (it->transport_scrambling_mode != 0) { 1364 // TODO: handle keyId change, use the first non-zero keyId for now. 1365 if (tsScramblingControl == 0) { 1366 tsScramblingControl = it->transport_scrambling_mode; 1367 } 1368 } 1369 if (tsScramblingControl == 0 || descrambleSubSamples == 0 1370 || !mQueue->isScrambled()) { 1371 descrambleSubSamples++; 1372 descrambleBytes += it->subSampleSize; 1373 } 1374 } 1375 // If not scrambled at TS-level, check PES-level scrambling 1376 if (tsScramblingControl == 0) { 1377 ABitReader br(mBuffer->data(), mBuffer->size()); 1378 pesScramblingControl = getPesScramblingControl(&br, &pesOffset); 1379 // If not scrambled at PES-level either, or scrambled at PES-level but 1380 // requires output to remain scrambled, we don't need to descramble 1381 // anything. 1382 if (pesScramblingControl == 0 || mQueue->isScrambled()) { 1383 descrambleSubSamples = 0; 1384 descrambleBytes = 0; 1385 } 1386 } 1387 1388 uint32_t sctrl = tsScramblingControl != 0 ? 1389 tsScramblingControl : pesScramblingControl; 1390 1391 // Perform the 1st pass descrambling if needed 1392 if (descrambleBytes > 0) { 1393 memcpy(mDescrambledBuffer->data(), mBuffer->data(), descrambleBytes); 1394 mDescrambledBuffer->setRange(0, descrambleBytes); 1395 1396 hidl_vec<SubSample> subSamples; 1397 subSamples.resize(descrambleSubSamples); 1398 1399 int32_t i = 0; 1400 for (auto it = mSubSamples.begin(); 1401 it != mSubSamples.end() && i < descrambleSubSamples; it++, i++) { 1402 if (it->transport_scrambling_mode != 0 || pesScramblingControl != 0) { 1403 subSamples[i].numBytesOfClearData = 0; 1404 subSamples[i].numBytesOfEncryptedData = it->subSampleSize; 1405 } else { 1406 subSamples[i].numBytesOfClearData = it->subSampleSize; 1407 subSamples[i].numBytesOfEncryptedData = 0; 1408 } 1409 } 1410 1411 uint64_t srcOffset = 0, dstOffset = 0; 1412 // If scrambled at PES-level, PES header should be skipped 1413 if (pesScramblingControl != 0) { 1414 srcOffset = dstOffset = pesOffset; 1415 subSamples[0].numBytesOfEncryptedData -= pesOffset; 1416 } 1417 1418 Status status = Status::OK; 1419 uint32_t bytesWritten = 0; 1420 hidl_string detailedError; 1421 1422 DestinationBuffer dstBuffer; 1423 dstBuffer.type = BufferType::SHARED_MEMORY; 1424 dstBuffer.nonsecureMemory = mDescramblerSrcBuffer; 1425 1426 auto returnVoid = mDescrambler->descramble( 1427 (ScramblingControl) sctrl, 1428 subSamples, 1429 mDescramblerSrcBuffer, 1430 srcOffset, 1431 dstBuffer, 1432 dstOffset, 1433 [&status, &bytesWritten, &detailedError] ( 1434 Status _status, uint32_t _bytesWritten, 1435 const hidl_string& _detailedError) { 1436 status = _status; 1437 bytesWritten = _bytesWritten; 1438 detailedError = _detailedError; 1439 }); 1440 1441 if (!returnVoid.isOk()) { 1442 ALOGE("[stream %d] descramble failed, trans=%s", 1443 mElementaryPID, returnVoid.description().c_str()); 1444 return UNKNOWN_ERROR; 1445 } 1446 1447 ALOGV("[stream %d] descramble succeeded, %d bytes", 1448 mElementaryPID, bytesWritten); 1449 memcpy(mBuffer->data(), mDescrambledBuffer->data(), descrambleBytes); 1450 } 1451 1452 if (mQueue->isScrambled()) { 1453 // Queue subSample info for scrambled queue 1454 sp<ABuffer> clearSizesBuffer = new ABuffer(mSubSamples.size() * 4); 1455 sp<ABuffer> encSizesBuffer = new ABuffer(mSubSamples.size() * 4); 1456 int32_t *clearSizePtr = (int32_t*)clearSizesBuffer->data(); 1457 int32_t *encSizePtr = (int32_t*)encSizesBuffer->data(); 1458 int32_t isSync = 0; 1459 int32_t i = 0; 1460 for (auto it = mSubSamples.begin(); 1461 it != mSubSamples.end(); it++, i++) { 1462 if ((it->transport_scrambling_mode == 0 1463 && pesScramblingControl == 0) 1464 || i < descrambleSubSamples) { 1465 clearSizePtr[i] = it->subSampleSize; 1466 encSizePtr[i] = 0; 1467 } else { 1468 clearSizePtr[i] = 0; 1469 encSizePtr[i] = it->subSampleSize; 1470 } 1471 isSync |= it->random_access_indicator; 1472 } 1473 // Pass the original TS subsample size now. The PES header adjust 1474 // will be applied when the scrambled AU is dequeued. 1475 mQueue->appendScrambledData( 1476 mBuffer->data(), mBuffer->size(), sctrl, 1477 isSync, clearSizesBuffer, encSizesBuffer); 1478 } 1479 1480 ABitReader br(mBuffer->data(), mBuffer->size()); 1481 status_t err = parsePES(&br, event); 1482 1483 if (err != OK) { 1484 ALOGE("[stream %d] failed to parse descrambled PES, err=%d", 1485 mElementaryPID, err); 1486 } 1487 1488 return err; 1489 } 1490 1491 1492 status_t ATSParser::Stream::flush(SyncEvent *event) { 1493 if (mBuffer == NULL || mBuffer->size() == 0) { 1494 return OK; 1495 } 1496 1497 ALOGV("flushing stream 0x%04x size = %zu", mElementaryPID, mBuffer->size()); 1498 1499 status_t err = OK; 1500 if (mScrambled) { 1501 err = flushScrambled(event); 1502 mSubSamples.clear(); 1503 } else { 1504 ABitReader br(mBuffer->data(), mBuffer->size()); 1505 err = parsePES(&br, event); 1506 } 1507 1508 mBuffer->setRange(0, 0); 1509 1510 return err; 1511 } 1512 1513 void ATSParser::Stream::onPayloadData( 1514 unsigned PTS_DTS_flags, uint64_t PTS, uint64_t /* DTS */, 1515 unsigned PES_scrambling_control, 1516 const uint8_t *data, size_t size, 1517 int32_t payloadOffset, SyncEvent *event) { 1518 #if 0 1519 ALOGI("payload streamType 0x%02x, PTS = 0x%016llx, dPTS = %lld", 1520 mStreamType, 1521 PTS, 1522 (int64_t)PTS - mPrevPTS); 1523 mPrevPTS = PTS; 1524 #endif 1525 1526 ALOGV("onPayloadData mStreamType=0x%02x size: %zu", mStreamType, size); 1527 1528 int64_t timeUs = 0ll; // no presentation timestamp available. 1529 if (PTS_DTS_flags == 2 || PTS_DTS_flags == 3) { 1530 timeUs = mProgram->convertPTSToTimestamp(PTS); 1531 } 1532 1533 status_t err = mQueue->appendData( 1534 data, size, timeUs, payloadOffset, PES_scrambling_control); 1535 1536 if (mEOSReached) { 1537 mQueue->signalEOS(); 1538 } 1539 1540 if (err != OK) { 1541 return; 1542 } 1543 1544 sp<ABuffer> accessUnit; 1545 bool found = false; 1546 while ((accessUnit = mQueue->dequeueAccessUnit()) != NULL) { 1547 if (mSource == NULL) { 1548 sp<MetaData> meta = mQueue->getFormat(); 1549 1550 if (meta != NULL) { 1551 ALOGV("Stream PID 0x%08x of type 0x%02x now has data.", 1552 mElementaryPID, mStreamType); 1553 1554 const char *mime; 1555 if (meta->findCString(kKeyMIMEType, &mime) 1556 && !strcasecmp(mime, MEDIA_MIMETYPE_VIDEO_AVC)) { 1557 int32_t sync = 0; 1558 if (!accessUnit->meta()->findInt32("isSync", &sync) || !sync) { 1559 continue; 1560 } 1561 } 1562 mSource = new AnotherPacketSource(meta); 1563 mSource->queueAccessUnit(accessUnit); 1564 ALOGV("onPayloadData: created AnotherPacketSource PID 0x%08x of type 0x%02x", 1565 mElementaryPID, mStreamType); 1566 } 1567 } else if (mQueue->getFormat() != NULL) { 1568 // After a discontinuity we invalidate the queue's format 1569 // and won't enqueue any access units to the source until 1570 // the queue has reestablished the new format. 1571 1572 if (mSource->getFormat() == NULL) { 1573 mSource->setFormat(mQueue->getFormat()); 1574 } 1575 mSource->queueAccessUnit(accessUnit); 1576 } 1577 1578 // Every access unit has a pesStartOffset queued in |mPesStartOffsets|. 1579 off64_t pesStartOffset = -1; 1580 if (!mPesStartOffsets.empty()) { 1581 pesStartOffset = *mPesStartOffsets.begin(); 1582 mPesStartOffsets.erase(mPesStartOffsets.begin()); 1583 } 1584 1585 if (pesStartOffset >= 0 && (event != NULL) && !found && mQueue->getFormat() != NULL) { 1586 int32_t sync = 0; 1587 if (accessUnit->meta()->findInt32("isSync", &sync) && sync) { 1588 int64_t timeUs; 1589 if (accessUnit->meta()->findInt64("timeUs", &timeUs)) { 1590 found = true; 1591 event->init(pesStartOffset, mSource, timeUs, getSourceType()); 1592 } 1593 } 1594 } 1595 } 1596 } 1597 1598 ATSParser::SourceType ATSParser::Stream::getSourceType() { 1599 if (isVideo()) { 1600 return VIDEO; 1601 } else if (isAudio()) { 1602 return AUDIO; 1603 } else if (isMeta()) { 1604 return META; 1605 } 1606 return NUM_SOURCE_TYPES; 1607 } 1608 1609 sp<MediaSource> ATSParser::Stream::getSource(SourceType type) { 1610 switch (type) { 1611 case VIDEO: 1612 { 1613 if (isVideo()) { 1614 return mSource; 1615 } 1616 break; 1617 } 1618 1619 case AUDIO: 1620 { 1621 if (isAudio()) { 1622 return mSource; 1623 } 1624 break; 1625 } 1626 1627 case META: 1628 { 1629 if (isMeta()) { 1630 return mSource; 1631 } 1632 break; 1633 } 1634 1635 default: 1636 break; 1637 } 1638 1639 return NULL; 1640 } 1641 1642 void ATSParser::Stream::setCasInfo( 1643 int32_t systemId, const sp<IDescrambler> &descrambler, 1644 const std::vector<uint8_t> &sessionId) { 1645 if (mSource != NULL && mDescrambler == NULL && descrambler != NULL) { 1646 signalDiscontinuity(DISCONTINUITY_FORMAT_ONLY, NULL); 1647 mDescrambler = descrambler; 1648 if (mQueue->isScrambled()) { 1649 mQueue->setCasInfo(systemId, sessionId); 1650 } 1651 } 1652 } 1653 1654 //////////////////////////////////////////////////////////////////////////////// 1655 1656 ATSParser::ATSParser(uint32_t flags) 1657 : mFlags(flags), 1658 mAbsoluteTimeAnchorUs(-1ll), 1659 mTimeOffsetValid(false), 1660 mTimeOffsetUs(0ll), 1661 mLastRecoveredPTS(-1ll), 1662 mNumTSPacketsParsed(0), 1663 mNumPCRs(0) { 1664 mPSISections.add(0 /* PID */, new PSISection); 1665 mCasManager = new CasManager(); 1666 } 1667 1668 ATSParser::~ATSParser() { 1669 } 1670 1671 status_t ATSParser::feedTSPacket(const void *data, size_t size, 1672 SyncEvent *event) { 1673 if (size != kTSPacketSize) { 1674 ALOGE("Wrong TS packet size"); 1675 return BAD_VALUE; 1676 } 1677 1678 ABitReader br((const uint8_t *)data, kTSPacketSize); 1679 return parseTS(&br, event); 1680 } 1681 1682 status_t ATSParser::setMediaCas(const sp<ICas> &cas) { 1683 status_t err = mCasManager->setMediaCas(cas); 1684 if (err != OK) { 1685 return err; 1686 } 1687 for (size_t i = 0; i < mPrograms.size(); ++i) { 1688 mPrograms.editItemAt(i)->updateCasSessions(); 1689 } 1690 return OK; 1691 } 1692 1693 void ATSParser::signalDiscontinuity( 1694 DiscontinuityType type, const sp<AMessage> &extra) { 1695 int64_t mediaTimeUs; 1696 if ((type & DISCONTINUITY_TIME) && extra != NULL) { 1697 if (extra->findInt64(IStreamListener::kKeyMediaTimeUs, &mediaTimeUs)) { 1698 mAbsoluteTimeAnchorUs = mediaTimeUs; 1699 } 1700 if ((mFlags & TS_TIMESTAMPS_ARE_ABSOLUTE) 1701 && extra->findInt64( 1702 IStreamListener::kKeyRecentMediaTimeUs, &mediaTimeUs)) { 1703 if (mAbsoluteTimeAnchorUs >= 0ll) { 1704 mediaTimeUs -= mAbsoluteTimeAnchorUs; 1705 } 1706 if (mTimeOffsetValid) { 1707 mediaTimeUs -= mTimeOffsetUs; 1708 } 1709 mLastRecoveredPTS = (mediaTimeUs * 9) / 100; 1710 } 1711 } else if (type == DISCONTINUITY_ABSOLUTE_TIME) { 1712 int64_t timeUs; 1713 if (!extra->findInt64("timeUs", &timeUs)) { 1714 ALOGE("timeUs not found"); 1715 return; 1716 } 1717 1718 if (!mPrograms.empty()) { 1719 ALOGE("mPrograms is not empty"); 1720 return; 1721 } 1722 mAbsoluteTimeAnchorUs = timeUs; 1723 return; 1724 } else if (type == DISCONTINUITY_TIME_OFFSET) { 1725 int64_t offset; 1726 if (!extra->findInt64("offset", &offset)) { 1727 ALOGE("offset not found"); 1728 return; 1729 } 1730 1731 mTimeOffsetValid = true; 1732 mTimeOffsetUs = offset; 1733 return; 1734 } 1735 1736 for (size_t i = 0; i < mPrograms.size(); ++i) { 1737 mPrograms.editItemAt(i)->signalDiscontinuity(type, extra); 1738 } 1739 } 1740 1741 void ATSParser::signalEOS(status_t finalResult) { 1742 if (finalResult == (status_t) OK) { 1743 ALOGE("finalResult not OK"); 1744 return; 1745 } 1746 1747 for (size_t i = 0; i < mPrograms.size(); ++i) { 1748 mPrograms.editItemAt(i)->signalEOS(finalResult); 1749 } 1750 } 1751 1752 void ATSParser::parseProgramAssociationTable(ABitReader *br) { 1753 unsigned table_id = br->getBits(8); 1754 ALOGV(" table_id = %u", table_id); 1755 if (table_id != 0x00u) { 1756 ALOGE("PAT data error!"); 1757 return ; 1758 } 1759 unsigned section_syntax_indictor = br->getBits(1); 1760 ALOGV(" section_syntax_indictor = %u", section_syntax_indictor); 1761 1762 br->skipBits(1); // '0' 1763 MY_LOGV(" reserved = %u", br->getBits(2)); 1764 1765 unsigned section_length = br->getBits(12); 1766 ALOGV(" section_length = %u", section_length); 1767 1768 MY_LOGV(" transport_stream_id = %u", br->getBits(16)); 1769 MY_LOGV(" reserved = %u", br->getBits(2)); 1770 MY_LOGV(" version_number = %u", br->getBits(5)); 1771 MY_LOGV(" current_next_indicator = %u", br->getBits(1)); 1772 MY_LOGV(" section_number = %u", br->getBits(8)); 1773 MY_LOGV(" last_section_number = %u", br->getBits(8)); 1774 1775 size_t numProgramBytes = (section_length - 5 /* header */ - 4 /* crc */); 1776 1777 for (size_t i = 0; i < numProgramBytes / 4; ++i) { 1778 unsigned program_number = br->getBits(16); 1779 ALOGV(" program_number = %u", program_number); 1780 1781 MY_LOGV(" reserved = %u", br->getBits(3)); 1782 1783 if (program_number == 0) { 1784 MY_LOGV(" network_PID = 0x%04x", br->getBits(13)); 1785 } else { 1786 unsigned programMapPID = br->getBits(13); 1787 1788 ALOGV(" program_map_PID = 0x%04x", programMapPID); 1789 1790 bool found = false; 1791 for (size_t index = 0; index < mPrograms.size(); ++index) { 1792 const sp<Program> &program = mPrograms.itemAt(index); 1793 1794 if (program->number() == program_number) { 1795 program->updateProgramMapPID(programMapPID); 1796 found = true; 1797 break; 1798 } 1799 } 1800 1801 if (!found) { 1802 mPrograms.push( 1803 new Program(this, program_number, programMapPID, mLastRecoveredPTS)); 1804 if (mSampleAesKeyItem != NULL) { 1805 mPrograms.top()->signalNewSampleAesKey(mSampleAesKeyItem); 1806 } 1807 } 1808 1809 if (mPSISections.indexOfKey(programMapPID) < 0) { 1810 mPSISections.add(programMapPID, new PSISection); 1811 } 1812 } 1813 } 1814 1815 MY_LOGV(" CRC = 0x%08x", br->getBits(32)); 1816 } 1817 1818 status_t ATSParser::parsePID( 1819 ABitReader *br, unsigned PID, 1820 unsigned continuity_counter, 1821 unsigned payload_unit_start_indicator, 1822 unsigned transport_scrambling_control, 1823 unsigned random_access_indicator, 1824 SyncEvent *event) { 1825 ssize_t sectionIndex = mPSISections.indexOfKey(PID); 1826 1827 if (sectionIndex >= 0) { 1828 sp<PSISection> section = mPSISections.valueAt(sectionIndex); 1829 1830 if (payload_unit_start_indicator) { 1831 if (!section->isEmpty()) { 1832 ALOGW("parsePID encounters payload_unit_start_indicator when section is not empty"); 1833 section->clear(); 1834 } 1835 1836 unsigned skip = br->getBits(8); 1837 section->setSkipBytes(skip + 1); // skip filler bytes + pointer field itself 1838 br->skipBits(skip * 8); 1839 } 1840 1841 if (br->numBitsLeft() % 8 != 0) { 1842 return ERROR_MALFORMED; 1843 } 1844 status_t err = section->append(br->data(), br->numBitsLeft() / 8); 1845 1846 if (err != OK) { 1847 return err; 1848 } 1849 1850 if (!section->isComplete()) { 1851 return OK; 1852 } 1853 1854 if (!section->isCRCOkay()) { 1855 return BAD_VALUE; 1856 } 1857 ABitReader sectionBits(section->data(), section->size()); 1858 1859 if (PID == 0) { 1860 parseProgramAssociationTable(§ionBits); 1861 } else { 1862 bool handled = false; 1863 for (size_t i = 0; i < mPrograms.size(); ++i) { 1864 status_t err; 1865 if (!mPrograms.editItemAt(i)->parsePSISection( 1866 PID, §ionBits, &err)) { 1867 continue; 1868 } 1869 1870 if (err != OK) { 1871 return err; 1872 } 1873 1874 handled = true; 1875 break; 1876 } 1877 1878 if (!handled) { 1879 mPSISections.removeItem(PID); 1880 section.clear(); 1881 } 1882 } 1883 1884 if (section != NULL) { 1885 section->clear(); 1886 } 1887 1888 return OK; 1889 } 1890 1891 bool handled = false; 1892 for (size_t i = 0; i < mPrograms.size(); ++i) { 1893 status_t err; 1894 if (mPrograms.editItemAt(i)->parsePID( 1895 PID, continuity_counter, 1896 payload_unit_start_indicator, 1897 transport_scrambling_control, 1898 random_access_indicator, 1899 br, &err, event)) { 1900 if (err != OK) { 1901 return err; 1902 } 1903 1904 handled = true; 1905 break; 1906 } 1907 } 1908 1909 if (!handled) { 1910 handled = mCasManager->parsePID(br, PID); 1911 } 1912 1913 if (!handled) { 1914 ALOGV("PID 0x%04x not handled.", PID); 1915 } 1916 1917 return OK; 1918 } 1919 1920 status_t ATSParser::parseAdaptationField( 1921 ABitReader *br, unsigned PID, unsigned *random_access_indicator) { 1922 *random_access_indicator = 0; 1923 unsigned adaptation_field_length = br->getBits(8); 1924 1925 if (adaptation_field_length > 0) { 1926 if (adaptation_field_length * 8 > br->numBitsLeft()) { 1927 ALOGV("Adaptation field should be included in a single TS packet."); 1928 return ERROR_MALFORMED; 1929 } 1930 1931 unsigned discontinuity_indicator = br->getBits(1); 1932 1933 if (discontinuity_indicator) { 1934 ALOGV("PID 0x%04x: discontinuity_indicator = 1 (!!!)", PID); 1935 } 1936 1937 *random_access_indicator = br->getBits(1); 1938 if (*random_access_indicator) { 1939 ALOGV("PID 0x%04x: random_access_indicator = 1", PID); 1940 } 1941 1942 unsigned elementary_stream_priority_indicator = br->getBits(1); 1943 if (elementary_stream_priority_indicator) { 1944 ALOGV("PID 0x%04x: elementary_stream_priority_indicator = 1", PID); 1945 } 1946 1947 unsigned PCR_flag = br->getBits(1); 1948 1949 size_t numBitsRead = 4; 1950 1951 if (PCR_flag) { 1952 if (adaptation_field_length * 8 < 52) { 1953 return ERROR_MALFORMED; 1954 } 1955 br->skipBits(4); 1956 uint64_t PCR_base = br->getBits(32); 1957 PCR_base = (PCR_base << 1) | br->getBits(1); 1958 1959 br->skipBits(6); 1960 unsigned PCR_ext = br->getBits(9); 1961 1962 // The number of bytes from the start of the current 1963 // MPEG2 transport stream packet up and including 1964 // the final byte of this PCR_ext field. 1965 size_t byteOffsetFromStartOfTSPacket = 1966 (188 - br->numBitsLeft() / 8); 1967 1968 uint64_t PCR = PCR_base * 300 + PCR_ext; 1969 1970 ALOGV("PID 0x%04x: PCR = 0x%016" PRIx64 " (%.2f)", 1971 PID, PCR, PCR / 27E6); 1972 1973 // The number of bytes received by this parser up to and 1974 // including the final byte of this PCR_ext field. 1975 uint64_t byteOffsetFromStart = 1976 uint64_t(mNumTSPacketsParsed) * 188 + byteOffsetFromStartOfTSPacket; 1977 1978 for (size_t i = 0; i < mPrograms.size(); ++i) { 1979 updatePCR(PID, PCR, byteOffsetFromStart); 1980 } 1981 1982 numBitsRead += 52; 1983 } 1984 1985 br->skipBits(adaptation_field_length * 8 - numBitsRead); 1986 } 1987 return OK; 1988 } 1989 1990 status_t ATSParser::parseTS(ABitReader *br, SyncEvent *event) { 1991 ALOGV("---"); 1992 1993 unsigned sync_byte = br->getBits(8); 1994 if (sync_byte != 0x47u) { 1995 ALOGE("[error] parseTS: return error as sync_byte=0x%x", sync_byte); 1996 return BAD_VALUE; 1997 } 1998 1999 if (br->getBits(1)) { // transport_error_indicator 2000 // silently ignore. 2001 return OK; 2002 } 2003 2004 unsigned payload_unit_start_indicator = br->getBits(1); 2005 ALOGV("payload_unit_start_indicator = %u", payload_unit_start_indicator); 2006 2007 MY_LOGV("transport_priority = %u", br->getBits(1)); 2008 2009 unsigned PID = br->getBits(13); 2010 ALOGV("PID = 0x%04x", PID); 2011 2012 unsigned transport_scrambling_control = br->getBits(2); 2013 ALOGV("transport_scrambling_control = %u", transport_scrambling_control); 2014 2015 unsigned adaptation_field_control = br->getBits(2); 2016 ALOGV("adaptation_field_control = %u", adaptation_field_control); 2017 2018 unsigned continuity_counter = br->getBits(4); 2019 ALOGV("PID = 0x%04x, continuity_counter = %u", PID, continuity_counter); 2020 2021 // ALOGI("PID = 0x%04x, continuity_counter = %u", PID, continuity_counter); 2022 2023 status_t err = OK; 2024 2025 unsigned random_access_indicator = 0; 2026 if (adaptation_field_control == 2 || adaptation_field_control == 3) { 2027 err = parseAdaptationField(br, PID, &random_access_indicator); 2028 } 2029 if (err == OK) { 2030 if (adaptation_field_control == 1 || adaptation_field_control == 3) { 2031 err = parsePID(br, PID, continuity_counter, 2032 payload_unit_start_indicator, 2033 transport_scrambling_control, 2034 random_access_indicator, 2035 event); 2036 } 2037 } 2038 2039 ++mNumTSPacketsParsed; 2040 2041 return err; 2042 } 2043 2044 sp<MediaSource> ATSParser::getSource(SourceType type) { 2045 sp<MediaSource> firstSourceFound; 2046 for (size_t i = 0; i < mPrograms.size(); ++i) { 2047 const sp<Program> &program = mPrograms.editItemAt(i); 2048 sp<MediaSource> source = program->getSource(type); 2049 if (source == NULL) { 2050 continue; 2051 } 2052 if (firstSourceFound == NULL) { 2053 firstSourceFound = source; 2054 } 2055 // Prefer programs with both audio/video 2056 switch (type) { 2057 case VIDEO: { 2058 if (program->hasSource(AUDIO)) { 2059 return source; 2060 } 2061 break; 2062 } 2063 2064 case AUDIO: { 2065 if (program->hasSource(VIDEO)) { 2066 return source; 2067 } 2068 break; 2069 } 2070 2071 default: 2072 return source; 2073 } 2074 } 2075 2076 return firstSourceFound; 2077 } 2078 2079 bool ATSParser::hasSource(SourceType type) const { 2080 for (size_t i = 0; i < mPrograms.size(); ++i) { 2081 const sp<Program> &program = mPrograms.itemAt(i); 2082 if (program->hasSource(type)) { 2083 return true; 2084 } 2085 } 2086 2087 return false; 2088 } 2089 2090 bool ATSParser::PTSTimeDeltaEstablished() { 2091 if (mPrograms.isEmpty()) { 2092 return false; 2093 } 2094 2095 return mPrograms.editItemAt(0)->PTSTimeDeltaEstablished(); 2096 } 2097 2098 int64_t ATSParser::getFirstPTSTimeUs() { 2099 for (size_t i = 0; i < mPrograms.size(); ++i) { 2100 sp<ATSParser::Program> program = mPrograms.itemAt(i); 2101 if (program->PTSTimeDeltaEstablished()) { 2102 return (program->firstPTS() * 100) / 9; 2103 } 2104 } 2105 return -1; 2106 } 2107 2108 __attribute__((no_sanitize("integer"))) 2109 void ATSParser::updatePCR( 2110 unsigned /* PID */, uint64_t PCR, uint64_t byteOffsetFromStart) { 2111 ALOGV("PCR 0x%016" PRIx64 " @ %" PRIx64, PCR, byteOffsetFromStart); 2112 2113 if (mNumPCRs == 2) { 2114 mPCR[0] = mPCR[1]; 2115 mPCRBytes[0] = mPCRBytes[1]; 2116 mSystemTimeUs[0] = mSystemTimeUs[1]; 2117 mNumPCRs = 1; 2118 } 2119 2120 mPCR[mNumPCRs] = PCR; 2121 mPCRBytes[mNumPCRs] = byteOffsetFromStart; 2122 mSystemTimeUs[mNumPCRs] = ALooper::GetNowUs(); 2123 2124 ++mNumPCRs; 2125 2126 if (mNumPCRs == 2) { 2127 /* Unsigned overflow here */ 2128 double transportRate = 2129 (mPCRBytes[1] - mPCRBytes[0]) * 27E6 / (mPCR[1] - mPCR[0]); 2130 2131 ALOGV("transportRate = %.2f bytes/sec", transportRate); 2132 } 2133 } 2134 2135 //////////////////////////////////////////////////////////////////////////////// 2136 2137 2138 // CRC32 used for PSI section. The table was generated by following command: 2139 // $ python pycrc.py --model crc-32-mpeg --algorithm table-driven --generate c 2140 // Visit http://www.tty1.net/pycrc/index_en.html for more details. 2141 uint32_t ATSParser::PSISection::CRC_TABLE[] = { 2142 0x00000000, 0x04c11db7, 0x09823b6e, 0x0d4326d9, 2143 0x130476dc, 0x17c56b6b, 0x1a864db2, 0x1e475005, 2144 0x2608edb8, 0x22c9f00f, 0x2f8ad6d6, 0x2b4bcb61, 2145 0x350c9b64, 0x31cd86d3, 0x3c8ea00a, 0x384fbdbd, 2146 0x4c11db70, 0x48d0c6c7, 0x4593e01e, 0x4152fda9, 2147 0x5f15adac, 0x5bd4b01b, 0x569796c2, 0x52568b75, 2148 0x6a1936c8, 0x6ed82b7f, 0x639b0da6, 0x675a1011, 2149 0x791d4014, 0x7ddc5da3, 0x709f7b7a, 0x745e66cd, 2150 0x9823b6e0, 0x9ce2ab57, 0x91a18d8e, 0x95609039, 2151 0x8b27c03c, 0x8fe6dd8b, 0x82a5fb52, 0x8664e6e5, 2152 0xbe2b5b58, 0xbaea46ef, 0xb7a96036, 0xb3687d81, 2153 0xad2f2d84, 0xa9ee3033, 0xa4ad16ea, 0xa06c0b5d, 2154 0xd4326d90, 0xd0f37027, 0xddb056fe, 0xd9714b49, 2155 0xc7361b4c, 0xc3f706fb, 0xceb42022, 0xca753d95, 2156 0xf23a8028, 0xf6fb9d9f, 0xfbb8bb46, 0xff79a6f1, 2157 0xe13ef6f4, 0xe5ffeb43, 0xe8bccd9a, 0xec7dd02d, 2158 0x34867077, 0x30476dc0, 0x3d044b19, 0x39c556ae, 2159 0x278206ab, 0x23431b1c, 0x2e003dc5, 0x2ac12072, 2160 0x128e9dcf, 0x164f8078, 0x1b0ca6a1, 0x1fcdbb16, 2161 0x018aeb13, 0x054bf6a4, 0x0808d07d, 0x0cc9cdca, 2162 0x7897ab07, 0x7c56b6b0, 0x71159069, 0x75d48dde, 2163 0x6b93dddb, 0x6f52c06c, 0x6211e6b5, 0x66d0fb02, 2164 0x5e9f46bf, 0x5a5e5b08, 0x571d7dd1, 0x53dc6066, 2165 0x4d9b3063, 0x495a2dd4, 0x44190b0d, 0x40d816ba, 2166 0xaca5c697, 0xa864db20, 0xa527fdf9, 0xa1e6e04e, 2167 0xbfa1b04b, 0xbb60adfc, 0xb6238b25, 0xb2e29692, 2168 0x8aad2b2f, 0x8e6c3698, 0x832f1041, 0x87ee0df6, 2169 0x99a95df3, 0x9d684044, 0x902b669d, 0x94ea7b2a, 2170 0xe0b41de7, 0xe4750050, 0xe9362689, 0xedf73b3e, 2171 0xf3b06b3b, 0xf771768c, 0xfa325055, 0xfef34de2, 2172 0xc6bcf05f, 0xc27dede8, 0xcf3ecb31, 0xcbffd686, 2173 0xd5b88683, 0xd1799b34, 0xdc3abded, 0xd8fba05a, 2174 0x690ce0ee, 0x6dcdfd59, 0x608edb80, 0x644fc637, 2175 0x7a089632, 0x7ec98b85, 0x738aad5c, 0x774bb0eb, 2176 0x4f040d56, 0x4bc510e1, 0x46863638, 0x42472b8f, 2177 0x5c007b8a, 0x58c1663d, 0x558240e4, 0x51435d53, 2178 0x251d3b9e, 0x21dc2629, 0x2c9f00f0, 0x285e1d47, 2179 0x36194d42, 0x32d850f5, 0x3f9b762c, 0x3b5a6b9b, 2180 0x0315d626, 0x07d4cb91, 0x0a97ed48, 0x0e56f0ff, 2181 0x1011a0fa, 0x14d0bd4d, 0x19939b94, 0x1d528623, 2182 0xf12f560e, 0xf5ee4bb9, 0xf8ad6d60, 0xfc6c70d7, 2183 0xe22b20d2, 0xe6ea3d65, 0xeba91bbc, 0xef68060b, 2184 0xd727bbb6, 0xd3e6a601, 0xdea580d8, 0xda649d6f, 2185 0xc423cd6a, 0xc0e2d0dd, 0xcda1f604, 0xc960ebb3, 2186 0xbd3e8d7e, 0xb9ff90c9, 0xb4bcb610, 0xb07daba7, 2187 0xae3afba2, 0xaafbe615, 0xa7b8c0cc, 0xa379dd7b, 2188 0x9b3660c6, 0x9ff77d71, 0x92b45ba8, 0x9675461f, 2189 0x8832161a, 0x8cf30bad, 0x81b02d74, 0x857130c3, 2190 0x5d8a9099, 0x594b8d2e, 0x5408abf7, 0x50c9b640, 2191 0x4e8ee645, 0x4a4ffbf2, 0x470cdd2b, 0x43cdc09c, 2192 0x7b827d21, 0x7f436096, 0x7200464f, 0x76c15bf8, 2193 0x68860bfd, 0x6c47164a, 0x61043093, 0x65c52d24, 2194 0x119b4be9, 0x155a565e, 0x18197087, 0x1cd86d30, 2195 0x029f3d35, 0x065e2082, 0x0b1d065b, 0x0fdc1bec, 2196 0x3793a651, 0x3352bbe6, 0x3e119d3f, 0x3ad08088, 2197 0x2497d08d, 0x2056cd3a, 0x2d15ebe3, 0x29d4f654, 2198 0xc5a92679, 0xc1683bce, 0xcc2b1d17, 0xc8ea00a0, 2199 0xd6ad50a5, 0xd26c4d12, 0xdf2f6bcb, 0xdbee767c, 2200 0xe3a1cbc1, 0xe760d676, 0xea23f0af, 0xeee2ed18, 2201 0xf0a5bd1d, 0xf464a0aa, 0xf9278673, 0xfde69bc4, 2202 0x89b8fd09, 0x8d79e0be, 0x803ac667, 0x84fbdbd0, 2203 0x9abc8bd5, 0x9e7d9662, 0x933eb0bb, 0x97ffad0c, 2204 0xafb010b1, 0xab710d06, 0xa6322bdf, 0xa2f33668, 2205 0xbcb4666d, 0xb8757bda, 0xb5365d03, 0xb1f740b4 2206 }; 2207 2208 ATSParser::PSISection::PSISection() : 2209 mSkipBytes(0) { 2210 } 2211 2212 ATSParser::PSISection::~PSISection() { 2213 } 2214 2215 status_t ATSParser::PSISection::append(const void *data, size_t size) { 2216 if (mBuffer == NULL || mBuffer->size() + size > mBuffer->capacity()) { 2217 size_t newCapacity = 2218 (mBuffer == NULL) ? size : mBuffer->capacity() + size; 2219 2220 newCapacity = (newCapacity + 1023) & ~1023; 2221 2222 sp<ABuffer> newBuffer = new ABuffer(newCapacity); 2223 2224 if (mBuffer != NULL) { 2225 memcpy(newBuffer->data(), mBuffer->data(), mBuffer->size()); 2226 newBuffer->setRange(0, mBuffer->size()); 2227 } else { 2228 newBuffer->setRange(0, 0); 2229 } 2230 2231 mBuffer = newBuffer; 2232 } 2233 2234 memcpy(mBuffer->data() + mBuffer->size(), data, size); 2235 mBuffer->setRange(0, mBuffer->size() + size); 2236 2237 return OK; 2238 } 2239 2240 void ATSParser::PSISection::setSkipBytes(uint8_t skip) { 2241 mSkipBytes = skip; 2242 } 2243 2244 void ATSParser::PSISection::clear() { 2245 if (mBuffer != NULL) { 2246 mBuffer->setRange(0, 0); 2247 } 2248 mSkipBytes = 0; 2249 } 2250 2251 bool ATSParser::PSISection::isComplete() const { 2252 if (mBuffer == NULL || mBuffer->size() < 3) { 2253 return false; 2254 } 2255 2256 unsigned sectionLength = U16_AT(mBuffer->data() + 1) & 0xfff; 2257 return mBuffer->size() >= sectionLength + 3; 2258 } 2259 2260 bool ATSParser::PSISection::isEmpty() const { 2261 return mBuffer == NULL || mBuffer->size() == 0; 2262 } 2263 2264 const uint8_t *ATSParser::PSISection::data() const { 2265 return mBuffer == NULL ? NULL : mBuffer->data(); 2266 } 2267 2268 size_t ATSParser::PSISection::size() const { 2269 return mBuffer == NULL ? 0 : mBuffer->size(); 2270 } 2271 2272 bool ATSParser::PSISection::isCRCOkay() const { 2273 if (!isComplete()) { 2274 return false; 2275 } 2276 uint8_t* data = mBuffer->data(); 2277 2278 // Return true if section_syntax_indicator says no section follows the field section_length. 2279 if ((data[1] & 0x80) == 0) { 2280 return true; 2281 } 2282 2283 unsigned sectionLength = U16_AT(data + 1) & 0xfff; 2284 ALOGV("sectionLength %u, skip %u", sectionLength, mSkipBytes); 2285 2286 2287 if(sectionLength < mSkipBytes) { 2288 ALOGE("b/28333006"); 2289 android_errorWriteLog(0x534e4554, "28333006"); 2290 return false; 2291 } 2292 2293 // Skip the preceding field present when payload start indicator is on. 2294 sectionLength -= mSkipBytes; 2295 2296 uint32_t crc = 0xffffffff; 2297 for(unsigned i = 0; i < sectionLength + 4 /* crc */; i++) { 2298 uint8_t b = data[i]; 2299 int index = ((crc >> 24) ^ (b & 0xff)) & 0xff; 2300 crc = CRC_TABLE[index] ^ (crc << 8); 2301 } 2302 ALOGV("crc: %08x\n", crc); 2303 return (crc == 0); 2304 } 2305 2306 // SAMPLE_AES key handling 2307 // TODO: Merge these to their respective class after Widevine-HLS 2308 void ATSParser::signalNewSampleAesKey(const sp<AMessage> &keyItem) { 2309 ALOGD("signalNewSampleAesKey: %p", keyItem.get()); 2310 2311 mSampleAesKeyItem = keyItem; 2312 2313 // a NULL key item will propagate to existing ElementaryStreamQueues 2314 for (size_t i = 0; i < mPrograms.size(); ++i) { 2315 mPrograms[i]->signalNewSampleAesKey(keyItem); 2316 } 2317 } 2318 2319 void ATSParser::Program::signalNewSampleAesKey(const sp<AMessage> &keyItem) { 2320 ALOGD("Program::signalNewSampleAesKey: %p", keyItem.get()); 2321 2322 mSampleAesKeyItem = keyItem; 2323 2324 // a NULL key item will propagate to existing ElementaryStreamQueues 2325 for (size_t i = 0; i < mStreams.size(); ++i) { 2326 mStreams[i]->signalNewSampleAesKey(keyItem); 2327 } 2328 } 2329 2330 void ATSParser::Stream::signalNewSampleAesKey(const sp<AMessage> &keyItem) { 2331 ALOGD("Stream::signalNewSampleAesKey: 0x%04x size = %zu keyItem: %p", 2332 mElementaryPID, mBuffer->size(), keyItem.get()); 2333 2334 // a NULL key item will propagate to existing ElementaryStreamQueues 2335 mSampleAesKeyItem = keyItem; 2336 2337 flush(NULL); 2338 mQueue->signalNewSampleAesKey(keyItem); 2339 } 2340 2341 } // namespace android 2342
