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