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 "ESQueue" 19#include <media/stagefright/foundation/ADebug.h> 20 21#include "ESQueue.h" 22 23#include <media/stagefright/foundation/hexdump.h> 24#include <media/stagefright/foundation/ABitReader.h> 25#include <media/stagefright/foundation/ABuffer.h> 26#include <media/stagefright/foundation/AMessage.h> 27#include <media/stagefright/MediaErrors.h> 28#include <media/stagefright/MediaDefs.h> 29#include <media/stagefright/MetaData.h> 30#include <media/stagefright/Utils.h> 31#include <media/cas/DescramblerAPI.h> 32#include <media/hardware/CryptoAPI.h> 33 34#include "include/avc_utils.h" 35 36#include <inttypes.h> 37#include <netinet/in.h> 38 39namespace android { 40 41ElementaryStreamQueue::ElementaryStreamQueue(Mode mode, uint32_t flags) 42 : mMode(mode), 43 mFlags(flags), 44 mEOSReached(false), 45 mCASystemId(0), 46 mAUIndex(0) { 47 48 ALOGV("ElementaryStreamQueue(%p) mode %x flags %x isScrambled %d isSampleEncrypted %d", 49 this, mode, flags, isScrambled(), isSampleEncrypted()); 50 51 // Create the decryptor anyway since we don't know the use-case unless key is provided 52 // Won't decrypt if key info not available (e.g., scanner/extractor just parsing ts files) 53 mSampleDecryptor = isSampleEncrypted() ? new HlsSampleDecryptor : NULL; 54} 55 56sp<MetaData> ElementaryStreamQueue::getFormat() { 57 return mFormat; 58} 59 60void ElementaryStreamQueue::clear(bool clearFormat) { 61 if (mBuffer != NULL) { 62 mBuffer->setRange(0, 0); 63 } 64 65 mRangeInfos.clear(); 66 67 if (mScrambledBuffer != NULL) { 68 mScrambledBuffer->setRange(0, 0); 69 } 70 mScrambledRangeInfos.clear(); 71 72 if (clearFormat) { 73 mFormat.clear(); 74 } 75 76 mEOSReached = false; 77} 78 79bool ElementaryStreamQueue::isScrambled() const { 80 return (mFlags & kFlag_ScrambledData) != 0; 81} 82 83void ElementaryStreamQueue::setCasInfo( 84 int32_t systemId, const std::vector<uint8_t> &sessionId) { 85 mCASystemId = systemId; 86 mCasSessionId = sessionId; 87} 88 89// Parse AC3 header assuming the current ptr is start position of syncframe, 90// update metadata only applicable, and return the payload size 91static unsigned parseAC3SyncFrame( 92 const uint8_t *ptr, size_t size, sp<MetaData> *metaData) { 93 static const unsigned channelCountTable[] = {2, 1, 2, 3, 3, 4, 4, 5}; 94 static const unsigned samplingRateTable[] = {48000, 44100, 32000}; 95 96 static const unsigned frameSizeTable[19][3] = { 97 { 64, 69, 96 }, 98 { 80, 87, 120 }, 99 { 96, 104, 144 }, 100 { 112, 121, 168 }, 101 { 128, 139, 192 }, 102 { 160, 174, 240 }, 103 { 192, 208, 288 }, 104 { 224, 243, 336 }, 105 { 256, 278, 384 }, 106 { 320, 348, 480 }, 107 { 384, 417, 576 }, 108 { 448, 487, 672 }, 109 { 512, 557, 768 }, 110 { 640, 696, 960 }, 111 { 768, 835, 1152 }, 112 { 896, 975, 1344 }, 113 { 1024, 1114, 1536 }, 114 { 1152, 1253, 1728 }, 115 { 1280, 1393, 1920 }, 116 }; 117 118 ABitReader bits(ptr, size); 119 if (bits.numBitsLeft() < 16) { 120 return 0; 121 } 122 if (bits.getBits(16) != 0x0B77) { 123 return 0; 124 } 125 126 if (bits.numBitsLeft() < 16 + 2 + 6 + 5 + 3 + 3) { 127 ALOGV("Not enough bits left for further parsing"); 128 return 0; 129 } 130 bits.skipBits(16); // crc1 131 132 unsigned fscod = bits.getBits(2); 133 if (fscod == 3) { 134 ALOGW("Incorrect fscod in AC3 header"); 135 return 0; 136 } 137 138 unsigned frmsizecod = bits.getBits(6); 139 if (frmsizecod > 37) { 140 ALOGW("Incorrect frmsizecod in AC3 header"); 141 return 0; 142 } 143 144 unsigned bsid = bits.getBits(5); 145 if (bsid > 8) { 146 ALOGW("Incorrect bsid in AC3 header. Possibly E-AC-3?"); 147 return 0; 148 } 149 150 unsigned bsmod __unused = bits.getBits(3); 151 unsigned acmod = bits.getBits(3); 152 unsigned cmixlev __unused = 0; 153 unsigned surmixlev __unused = 0; 154 unsigned dsurmod __unused = 0; 155 156 if ((acmod & 1) > 0 && acmod != 1) { 157 if (bits.numBitsLeft() < 2) { 158 return 0; 159 } 160 cmixlev = bits.getBits(2); 161 } 162 if ((acmod & 4) > 0) { 163 if (bits.numBitsLeft() < 2) { 164 return 0; 165 } 166 surmixlev = bits.getBits(2); 167 } 168 if (acmod == 2) { 169 if (bits.numBitsLeft() < 2) { 170 return 0; 171 } 172 dsurmod = bits.getBits(2); 173 } 174 175 if (bits.numBitsLeft() < 1) { 176 return 0; 177 } 178 unsigned lfeon = bits.getBits(1); 179 180 unsigned samplingRate = samplingRateTable[fscod]; 181 unsigned payloadSize = frameSizeTable[frmsizecod >> 1][fscod]; 182 if (fscod == 1) { 183 payloadSize += frmsizecod & 1; 184 } 185 payloadSize <<= 1; // convert from 16-bit words to bytes 186 187 unsigned channelCount = channelCountTable[acmod] + lfeon; 188 189 if (metaData != NULL) { 190 (*metaData)->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_AC3); 191 (*metaData)->setInt32(kKeyChannelCount, channelCount); 192 (*metaData)->setInt32(kKeySampleRate, samplingRate); 193 } 194 195 return payloadSize; 196} 197 198static bool IsSeeminglyValidAC3Header(const uint8_t *ptr, size_t size) { 199 return parseAC3SyncFrame(ptr, size, NULL) > 0; 200} 201 202static bool IsSeeminglyValidADTSHeader( 203 const uint8_t *ptr, size_t size, size_t *frameLength) { 204 if (size < 7) { 205 // Not enough data to verify header. 206 return false; 207 } 208 209 if (ptr[0] != 0xff || (ptr[1] >> 4) != 0x0f) { 210 return false; 211 } 212 213 unsigned layer = (ptr[1] >> 1) & 3; 214 215 if (layer != 0) { 216 return false; 217 } 218 219 unsigned ID = (ptr[1] >> 3) & 1; 220 unsigned profile_ObjectType = ptr[2] >> 6; 221 222 if (ID == 1 && profile_ObjectType == 3) { 223 // MPEG-2 profile 3 is reserved. 224 return false; 225 } 226 227 size_t frameLengthInHeader = 228 ((ptr[3] & 3) << 11) + (ptr[4] << 3) + ((ptr[5] >> 5) & 7); 229 if (frameLengthInHeader > size) { 230 return false; 231 } 232 233 *frameLength = frameLengthInHeader; 234 return true; 235} 236 237static bool IsSeeminglyValidMPEGAudioHeader(const uint8_t *ptr, size_t size) { 238 if (size < 3) { 239 // Not enough data to verify header. 240 return false; 241 } 242 243 if (ptr[0] != 0xff || (ptr[1] >> 5) != 0x07) { 244 return false; 245 } 246 247 unsigned ID = (ptr[1] >> 3) & 3; 248 249 if (ID == 1) { 250 return false; // reserved 251 } 252 253 unsigned layer = (ptr[1] >> 1) & 3; 254 255 if (layer == 0) { 256 return false; // reserved 257 } 258 259 unsigned bitrateIndex = (ptr[2] >> 4); 260 261 if (bitrateIndex == 0x0f) { 262 return false; // reserved 263 } 264 265 unsigned samplingRateIndex = (ptr[2] >> 2) & 3; 266 267 if (samplingRateIndex == 3) { 268 return false; // reserved 269 } 270 271 return true; 272} 273 274status_t ElementaryStreamQueue::appendData( 275 const void *data, size_t size, int64_t timeUs, 276 int32_t payloadOffset, uint32_t pesScramblingControl) { 277 278 if (mEOSReached) { 279 ALOGE("appending data after EOS"); 280 return ERROR_MALFORMED; 281 } 282 if (mBuffer == NULL || mBuffer->size() == 0) { 283 switch (mMode) { 284 case H264: 285 case MPEG_VIDEO: 286 { 287#if 0 288 if (size < 4 || memcmp("\x00\x00\x00\x01", data, 4)) { 289 return ERROR_MALFORMED; 290 } 291#else 292 uint8_t *ptr = (uint8_t *)data; 293 294 ssize_t startOffset = -1; 295 for (size_t i = 0; i + 2 < size; ++i) { 296 if (!memcmp("\x00\x00\x01", &ptr[i], 3)) { 297 startOffset = i; 298 break; 299 } 300 } 301 302 if (startOffset < 0) { 303 return ERROR_MALFORMED; 304 } 305 306 if (mFormat == NULL && startOffset > 0) { 307 ALOGI("found something resembling an H.264/MPEG syncword " 308 "at offset %zd", 309 startOffset); 310 } 311 312 data = &ptr[startOffset]; 313 size -= startOffset; 314#endif 315 break; 316 } 317 318 case MPEG4_VIDEO: 319 { 320#if 0 321 if (size < 3 || memcmp("\x00\x00\x01", data, 3)) { 322 return ERROR_MALFORMED; 323 } 324#else 325 uint8_t *ptr = (uint8_t *)data; 326 327 ssize_t startOffset = -1; 328 for (size_t i = 0; i + 2 < size; ++i) { 329 if (!memcmp("\x00\x00\x01", &ptr[i], 3)) { 330 startOffset = i; 331 break; 332 } 333 } 334 335 if (startOffset < 0) { 336 return ERROR_MALFORMED; 337 } 338 339 if (startOffset > 0) { 340 ALOGI("found something resembling an H.264/MPEG syncword " 341 "at offset %zd", 342 startOffset); 343 } 344 345 data = &ptr[startOffset]; 346 size -= startOffset; 347#endif 348 break; 349 } 350 351 case AAC: 352 { 353 uint8_t *ptr = (uint8_t *)data; 354 355#if 0 356 if (size < 2 || ptr[0] != 0xff || (ptr[1] >> 4) != 0x0f) { 357 return ERROR_MALFORMED; 358 } 359#else 360 ssize_t startOffset = -1; 361 size_t frameLength; 362 for (size_t i = 0; i < size; ++i) { 363 if (IsSeeminglyValidADTSHeader( 364 &ptr[i], size - i, &frameLength)) { 365 startOffset = i; 366 break; 367 } 368 } 369 370 if (startOffset < 0) { 371 return ERROR_MALFORMED; 372 } 373 374 if (startOffset > 0) { 375 ALOGI("found something resembling an AAC syncword at " 376 "offset %zd", 377 startOffset); 378 } 379 380 if (frameLength != size - startOffset) { 381 ALOGV("First ADTS AAC frame length is %zd bytes, " 382 "while the buffer size is %zd bytes.", 383 frameLength, size - startOffset); 384 } 385 386 data = &ptr[startOffset]; 387 size -= startOffset; 388#endif 389 break; 390 } 391 392 case AC3: 393 { 394 uint8_t *ptr = (uint8_t *)data; 395 396 ssize_t startOffset = -1; 397 for (size_t i = 0; i < size; ++i) { 398 if (IsSeeminglyValidAC3Header(&ptr[i], size - i)) { 399 startOffset = i; 400 break; 401 } 402 } 403 404 if (startOffset < 0) { 405 return ERROR_MALFORMED; 406 } 407 408 if (startOffset > 0) { 409 ALOGI("found something resembling an AC3 syncword at " 410 "offset %zd", 411 startOffset); 412 } 413 414 data = &ptr[startOffset]; 415 size -= startOffset; 416 break; 417 } 418 419 case MPEG_AUDIO: 420 { 421 uint8_t *ptr = (uint8_t *)data; 422 423 ssize_t startOffset = -1; 424 for (size_t i = 0; i < size; ++i) { 425 if (IsSeeminglyValidMPEGAudioHeader(&ptr[i], size - i)) { 426 startOffset = i; 427 break; 428 } 429 } 430 431 if (startOffset < 0) { 432 return ERROR_MALFORMED; 433 } 434 435 if (startOffset > 0) { 436 ALOGI("found something resembling an MPEG audio " 437 "syncword at offset %zd", 438 startOffset); 439 } 440 441 data = &ptr[startOffset]; 442 size -= startOffset; 443 break; 444 } 445 446 case PCM_AUDIO: 447 case METADATA: 448 { 449 break; 450 } 451 452 default: 453 ALOGE("Unknown mode: %d", mMode); 454 return ERROR_MALFORMED; 455 } 456 } 457 458 size_t neededSize = (mBuffer == NULL ? 0 : mBuffer->size()) + size; 459 if (mBuffer == NULL || neededSize > mBuffer->capacity()) { 460 neededSize = (neededSize + 65535) & ~65535; 461 462 ALOGV("resizing buffer to size %zu", neededSize); 463 464 sp<ABuffer> buffer = new ABuffer(neededSize); 465 if (mBuffer != NULL) { 466 memcpy(buffer->data(), mBuffer->data(), mBuffer->size()); 467 buffer->setRange(0, mBuffer->size()); 468 } else { 469 buffer->setRange(0, 0); 470 } 471 472 mBuffer = buffer; 473 } 474 475 memcpy(mBuffer->data() + mBuffer->size(), data, size); 476 mBuffer->setRange(0, mBuffer->size() + size); 477 478 RangeInfo info; 479 info.mLength = size; 480 info.mTimestampUs = timeUs; 481 info.mPesOffset = payloadOffset; 482 info.mPesScramblingControl = pesScramblingControl; 483 mRangeInfos.push_back(info); 484 485#if 0 486 if (mMode == AAC) { 487 ALOGI("size = %zu, timeUs = %.2f secs", size, timeUs / 1E6); 488 hexdump(data, size); 489 } 490#endif 491 492 return OK; 493} 494 495void ElementaryStreamQueue::appendScrambledData( 496 const void *data, size_t size, 497 int32_t keyId, bool isSync, 498 sp<ABuffer> clearSizes, sp<ABuffer> encSizes) { 499 if (!isScrambled()) { 500 return; 501 } 502 503 size_t neededSize = (mScrambledBuffer == NULL ? 0 : mScrambledBuffer->size()) + size; 504 if (mScrambledBuffer == NULL || neededSize > mScrambledBuffer->capacity()) { 505 neededSize = (neededSize + 65535) & ~65535; 506 507 ALOGI("resizing scrambled buffer to size %zu", neededSize); 508 509 sp<ABuffer> buffer = new ABuffer(neededSize); 510 if (mScrambledBuffer != NULL) { 511 memcpy(buffer->data(), mScrambledBuffer->data(), mScrambledBuffer->size()); 512 buffer->setRange(0, mScrambledBuffer->size()); 513 } else { 514 buffer->setRange(0, 0); 515 } 516 517 mScrambledBuffer = buffer; 518 } 519 memcpy(mScrambledBuffer->data() + mScrambledBuffer->size(), data, size); 520 mScrambledBuffer->setRange(0, mScrambledBuffer->size() + size); 521 522 ScrambledRangeInfo scrambledInfo; 523 scrambledInfo.mLength = size; 524 scrambledInfo.mKeyId = keyId; 525 scrambledInfo.mIsSync = isSync; 526 scrambledInfo.mClearSizes = clearSizes; 527 scrambledInfo.mEncSizes = encSizes; 528 529 ALOGV("[stream %d] appending scrambled range: size=%zu", mMode, size); 530 531 mScrambledRangeInfos.push_back(scrambledInfo); 532} 533 534sp<ABuffer> ElementaryStreamQueue::dequeueScrambledAccessUnit() { 535 size_t nextScan = mBuffer->size(); 536 mBuffer->setRange(0, 0); 537 int32_t pesOffset = 0, pesScramblingControl = 0; 538 int64_t timeUs = fetchTimestamp(nextScan, &pesOffset, &pesScramblingControl); 539 if (timeUs < 0ll) { 540 ALOGE("Negative timeUs"); 541 return NULL; 542 } 543 544 // return scrambled unit 545 int32_t keyId = pesScramblingControl, isSync = 0, scrambledLength = 0; 546 sp<ABuffer> clearSizes, encSizes; 547 while (mScrambledRangeInfos.size() > mRangeInfos.size()) { 548 auto it = mScrambledRangeInfos.begin(); 549 ALOGV("[stream %d] fetching scrambled range: size=%zu", mMode, it->mLength); 550 551 if (scrambledLength > 0) { 552 // This shouldn't happen since we always dequeue the entire PES. 553 ALOGW("Discarding srambled length %d", scrambledLength); 554 } 555 scrambledLength = it->mLength; 556 557 // TODO: handle key id change, use first non-zero keyId for now 558 if (keyId == 0) { 559 keyId = it->mKeyId; 560 } 561 clearSizes = it->mClearSizes; 562 encSizes = it->mEncSizes; 563 isSync = it->mIsSync; 564 mScrambledRangeInfos.erase(it); 565 } 566 if (scrambledLength == 0) { 567 ALOGE("[stream %d] empty scrambled unit!", mMode); 568 return NULL; 569 } 570 571 // skip the PES header, and copy the rest into scrambled access unit 572 sp<ABuffer> scrambledAccessUnit = ABuffer::CreateAsCopy( 573 mScrambledBuffer->data() + pesOffset, 574 scrambledLength - pesOffset); 575 576 // fix up first sample size after skipping the PES header 577 if (pesOffset > 0) { 578 int32_t &firstClearSize = *(int32_t*)clearSizes->data(); 579 int32_t &firstEncSize = *(int32_t*)encSizes->data(); 580 // Cut away the PES header 581 if (firstClearSize >= pesOffset) { 582 // This is for TS-level scrambling, we descrambled the first 583 // (or it was clear to begin with) 584 firstClearSize -= pesOffset; 585 } else if (firstEncSize >= pesOffset) { 586 // This can only be PES-level scrambling 587 firstEncSize -= pesOffset; 588 } 589 } 590 591 scrambledAccessUnit->meta()->setInt64("timeUs", timeUs); 592 if (isSync) { 593 scrambledAccessUnit->meta()->setInt32("isSync", 1); 594 } 595 596 // fill in CryptoInfo fields for AnotherPacketSource::read() 597 // MediaCas doesn't use cryptoMode, but set to non-zero value here. 598 scrambledAccessUnit->meta()->setInt32( 599 "cryptoMode", CryptoPlugin::kMode_AES_CTR); 600 scrambledAccessUnit->meta()->setInt32("cryptoKey", keyId); 601 scrambledAccessUnit->meta()->setBuffer("clearBytes", clearSizes); 602 scrambledAccessUnit->meta()->setBuffer("encBytes", encSizes); 603 604 memmove(mScrambledBuffer->data(), 605 mScrambledBuffer->data() + scrambledLength, 606 mScrambledBuffer->size() - scrambledLength); 607 608 mScrambledBuffer->setRange(0, mScrambledBuffer->size() - scrambledLength); 609 610 ALOGV("[stream %d] dequeued scrambled AU: timeUs=%lld, size=%zu", 611 mMode, (long long)timeUs, scrambledAccessUnit->size()); 612 613 return scrambledAccessUnit; 614} 615 616sp<ABuffer> ElementaryStreamQueue::dequeueAccessUnit() { 617 if ((mFlags & kFlag_AlignedData) && mMode == H264 && !isScrambled()) { 618 if (mRangeInfos.empty()) { 619 return NULL; 620 } 621 622 RangeInfo info = *mRangeInfos.begin(); 623 mRangeInfos.erase(mRangeInfos.begin()); 624 625 sp<ABuffer> accessUnit = new ABuffer(info.mLength); 626 memcpy(accessUnit->data(), mBuffer->data(), info.mLength); 627 accessUnit->meta()->setInt64("timeUs", info.mTimestampUs); 628 629 memmove(mBuffer->data(), 630 mBuffer->data() + info.mLength, 631 mBuffer->size() - info.mLength); 632 633 mBuffer->setRange(0, mBuffer->size() - info.mLength); 634 635 if (mFormat == NULL) { 636 mFormat = MakeAVCCodecSpecificData(accessUnit); 637 } 638 639 return accessUnit; 640 } 641 642 switch (mMode) { 643 case H264: 644 return dequeueAccessUnitH264(); 645 case AAC: 646 return dequeueAccessUnitAAC(); 647 case AC3: 648 return dequeueAccessUnitAC3(); 649 case MPEG_VIDEO: 650 return dequeueAccessUnitMPEGVideo(); 651 case MPEG4_VIDEO: 652 return dequeueAccessUnitMPEG4Video(); 653 case PCM_AUDIO: 654 return dequeueAccessUnitPCMAudio(); 655 case METADATA: 656 return dequeueAccessUnitMetadata(); 657 default: 658 if (mMode != MPEG_AUDIO) { 659 ALOGE("Unknown mode"); 660 return NULL; 661 } 662 return dequeueAccessUnitMPEGAudio(); 663 } 664} 665 666sp<ABuffer> ElementaryStreamQueue::dequeueAccessUnitAC3() { 667 unsigned syncStartPos = 0; // in bytes 668 unsigned payloadSize = 0; 669 sp<MetaData> format = new MetaData; 670 671 ALOGV("dequeueAccessUnit_AC3[%d]: mBuffer %p(%zu)", mAUIndex, mBuffer->data(), mBuffer->size()); 672 673 while (true) { 674 if (syncStartPos + 2 >= mBuffer->size()) { 675 return NULL; 676 } 677 678 payloadSize = parseAC3SyncFrame( 679 mBuffer->data() + syncStartPos, 680 mBuffer->size() - syncStartPos, 681 &format); 682 if (payloadSize > 0) { 683 break; 684 } 685 686 ALOGV("dequeueAccessUnit_AC3[%d]: syncStartPos %u payloadSize %u", 687 mAUIndex, syncStartPos, payloadSize); 688 689 ++syncStartPos; 690 } 691 692 if (mBuffer->size() < syncStartPos + payloadSize) { 693 ALOGV("Not enough buffer size for AC3"); 694 return NULL; 695 } 696 697 if (mFormat == NULL) { 698 mFormat = format; 699 } 700 701 702 int64_t timeUs = fetchTimestamp(syncStartPos + payloadSize); 703 if (timeUs < 0ll) { 704 ALOGE("negative timeUs"); 705 return NULL; 706 } 707 708 // Not decrypting if key info not available (e.g., scanner/extractor parsing ts files) 709 if (mSampleDecryptor != NULL) { 710 mSampleDecryptor->processAC3(mBuffer->data() + syncStartPos, payloadSize); 711 } 712 mAUIndex++; 713 714 sp<ABuffer> accessUnit = new ABuffer(syncStartPos + payloadSize); 715 memcpy(accessUnit->data(), mBuffer->data(), syncStartPos + payloadSize); 716 717 accessUnit->meta()->setInt64("timeUs", timeUs); 718 accessUnit->meta()->setInt32("isSync", 1); 719 720 memmove( 721 mBuffer->data(), 722 mBuffer->data() + syncStartPos + payloadSize, 723 mBuffer->size() - syncStartPos - payloadSize); 724 725 mBuffer->setRange(0, mBuffer->size() - syncStartPos - payloadSize); 726 727 return accessUnit; 728} 729 730sp<ABuffer> ElementaryStreamQueue::dequeueAccessUnitPCMAudio() { 731 if (mBuffer->size() < 4) { 732 return NULL; 733 } 734 735 ABitReader bits(mBuffer->data(), 4); 736 if (bits.getBits(8) != 0xa0) { 737 ALOGE("Unexpected bit values"); 738 return NULL; 739 } 740 unsigned numAUs = bits.getBits(8); 741 bits.skipBits(8); 742 unsigned quantization_word_length __unused = bits.getBits(2); 743 unsigned audio_sampling_frequency = bits.getBits(3); 744 unsigned num_channels = bits.getBits(3); 745 746 if (audio_sampling_frequency != 2) { 747 ALOGE("Wrong sampling freq"); 748 return NULL; 749 } 750 if (num_channels != 1u) { 751 ALOGE("Wrong channel #"); 752 return NULL; 753 } 754 755 if (mFormat == NULL) { 756 mFormat = new MetaData; 757 mFormat->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_RAW); 758 mFormat->setInt32(kKeyChannelCount, 2); 759 mFormat->setInt32(kKeySampleRate, 48000); 760 mFormat->setInt32(kKeyPcmEncoding, kAudioEncodingPcm16bit); 761 } 762 763 static const size_t kFramesPerAU = 80; 764 size_t frameSize = 2 /* numChannels */ * sizeof(int16_t); 765 766 size_t payloadSize = numAUs * frameSize * kFramesPerAU; 767 768 if (mBuffer->size() < 4 + payloadSize) { 769 return NULL; 770 } 771 772 sp<ABuffer> accessUnit = new ABuffer(payloadSize); 773 memcpy(accessUnit->data(), mBuffer->data() + 4, payloadSize); 774 775 int64_t timeUs = fetchTimestamp(payloadSize + 4); 776 if (timeUs < 0ll) { 777 ALOGE("Negative timeUs"); 778 return NULL; 779 } 780 accessUnit->meta()->setInt64("timeUs", timeUs); 781 accessUnit->meta()->setInt32("isSync", 1); 782 783 int16_t *ptr = (int16_t *)accessUnit->data(); 784 for (size_t i = 0; i < payloadSize / sizeof(int16_t); ++i) { 785 ptr[i] = ntohs(ptr[i]); 786 } 787 788 memmove( 789 mBuffer->data(), 790 mBuffer->data() + 4 + payloadSize, 791 mBuffer->size() - 4 - payloadSize); 792 793 mBuffer->setRange(0, mBuffer->size() - 4 - payloadSize); 794 795 return accessUnit; 796} 797 798sp<ABuffer> ElementaryStreamQueue::dequeueAccessUnitAAC() { 799 if (mBuffer->size() == 0) { 800 return NULL; 801 } 802 803 if (mRangeInfos.empty()) { 804 return NULL; 805 } 806 807 const RangeInfo &info = *mRangeInfos.begin(); 808 if (mBuffer->size() < info.mLength) { 809 return NULL; 810 } 811 812 if (info.mTimestampUs < 0ll) { 813 ALOGE("Negative info.mTimestampUs"); 814 return NULL; 815 } 816 817 ALOGV("dequeueAccessUnit_AAC[%d]: mBuffer %zu info.mLength %zu", 818 mAUIndex, mBuffer->size(), info.mLength); 819 820 struct ADTSPosition { 821 size_t offset; 822 size_t headerSize; 823 size_t length; 824 }; 825 826 Vector<ADTSPosition> frames; 827 828 // The idea here is consume all AAC frames starting at offsets before 829 // info.mLength so we can assign a meaningful timestamp without 830 // having to interpolate. 831 // The final AAC frame may well extend into the next RangeInfo but 832 // that's ok. 833 size_t offset = 0; 834 while (offset < info.mLength) { 835 if (offset + 7 > mBuffer->size()) { 836 return NULL; 837 } 838 839 ABitReader bits(mBuffer->data() + offset, mBuffer->size() - offset); 840 841 // adts_fixed_header 842 843 if (bits.getBits(12) != 0xfffu) { 844 ALOGE("Wrong atds_fixed_header"); 845 return NULL; 846 } 847 bits.skipBits(3); // ID, layer 848 bool protection_absent = bits.getBits(1) != 0; 849 850 if (mFormat == NULL) { 851 unsigned profile = bits.getBits(2); 852 if (profile == 3u) { 853 ALOGE("profile should not be 3"); 854 return NULL; 855 } 856 unsigned sampling_freq_index = bits.getBits(4); 857 bits.getBits(1); // private_bit 858 unsigned channel_configuration = bits.getBits(3); 859 if (channel_configuration == 0u) { 860 ALOGE("channel_config should not be 0"); 861 return NULL; 862 } 863 bits.skipBits(2); // original_copy, home 864 865 mFormat = MakeAACCodecSpecificData( 866 profile, sampling_freq_index, channel_configuration); 867 868 mFormat->setInt32(kKeyIsADTS, true); 869 870 int32_t sampleRate; 871 int32_t numChannels; 872 if (!mFormat->findInt32(kKeySampleRate, &sampleRate)) { 873 ALOGE("SampleRate not found"); 874 return NULL; 875 } 876 if (!mFormat->findInt32(kKeyChannelCount, &numChannels)) { 877 ALOGE("ChannelCount not found"); 878 return NULL; 879 } 880 881 ALOGI("found AAC codec config (%d Hz, %d channels)", 882 sampleRate, numChannels); 883 } else { 884 // profile_ObjectType, sampling_frequency_index, private_bits, 885 // channel_configuration, original_copy, home 886 bits.skipBits(12); 887 } 888 889 // adts_variable_header 890 891 // copyright_identification_bit, copyright_identification_start 892 bits.skipBits(2); 893 894 unsigned aac_frame_length = bits.getBits(13); 895 896 bits.skipBits(11); // adts_buffer_fullness 897 898 unsigned number_of_raw_data_blocks_in_frame = bits.getBits(2); 899 900 if (number_of_raw_data_blocks_in_frame != 0) { 901 // To be implemented. 902 ALOGE("Should not reach here."); 903 return NULL; 904 } 905 906 if (offset + aac_frame_length > mBuffer->size()) { 907 return NULL; 908 } 909 910 size_t headerSize = protection_absent ? 7 : 9; 911 912 // tracking the frame positions first then decrypt only if an accessUnit to be generated 913 if (mSampleDecryptor != NULL) { 914 ADTSPosition frame = { 915 .offset = offset, 916 .headerSize = headerSize, 917 .length = aac_frame_length 918 }; 919 920 frames.push(frame); 921 } 922 923 offset += aac_frame_length; 924 } 925 926 // Decrypting only if the loop didn't exit early and an accessUnit is about to be generated 927 // Not decrypting if key info not available (e.g., scanner/extractor parsing ts files) 928 if (mSampleDecryptor != NULL) { 929 for (size_t frameId = 0; frameId < frames.size(); frameId++) { 930 const ADTSPosition &frame = frames.itemAt(frameId); 931 932 mSampleDecryptor->processAAC(frame.headerSize, 933 mBuffer->data() + frame.offset, frame.length); 934// ALOGV("dequeueAccessUnitAAC[%zu]: while offset %zu headerSize %zu frame_len %zu", 935// frameId, frame.offset, frame.headerSize, frame.length); 936 } 937 } 938 mAUIndex++; 939 940 int64_t timeUs = fetchTimestamp(offset); 941 942 sp<ABuffer> accessUnit = new ABuffer(offset); 943 memcpy(accessUnit->data(), mBuffer->data(), offset); 944 945 memmove(mBuffer->data(), mBuffer->data() + offset, 946 mBuffer->size() - offset); 947 mBuffer->setRange(0, mBuffer->size() - offset); 948 949 accessUnit->meta()->setInt64("timeUs", timeUs); 950 accessUnit->meta()->setInt32("isSync", 1); 951 952 return accessUnit; 953} 954 955int64_t ElementaryStreamQueue::fetchTimestamp( 956 size_t size, int32_t *pesOffset, int32_t *pesScramblingControl) { 957 int64_t timeUs = -1; 958 bool first = true; 959 960 while (size > 0) { 961 if (mRangeInfos.empty()) { 962 return timeUs; 963 } 964 965 RangeInfo *info = &*mRangeInfos.begin(); 966 967 if (first) { 968 timeUs = info->mTimestampUs; 969 if (pesOffset != NULL) { 970 *pesOffset = info->mPesOffset; 971 } 972 if (pesScramblingControl != NULL) { 973 *pesScramblingControl = info->mPesScramblingControl; 974 } 975 first = false; 976 } 977 978 if (info->mLength > size) { 979 info->mLength -= size; 980 size = 0; 981 } else { 982 size -= info->mLength; 983 984 mRangeInfos.erase(mRangeInfos.begin()); 985 info = NULL; 986 } 987 988 } 989 990 if (timeUs == 0ll) { 991 ALOGV("Returning 0 timestamp"); 992 } 993 994 return timeUs; 995} 996 997sp<ABuffer> ElementaryStreamQueue::dequeueAccessUnitH264() { 998 if (isScrambled()) { 999 if (mBuffer == NULL || mBuffer->size() == 0) { 1000 return NULL; 1001 } 1002 if (mFormat == NULL) { 1003 mFormat = MakeAVCCodecSpecificData(mBuffer); 1004 if (mFormat == NULL) { 1005 ALOGI("Creating dummy AVC format for scrambled content"); 1006 mFormat = new MetaData; 1007 mFormat->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_AVC); 1008 mFormat->setInt32(kKeyWidth, 1280); 1009 mFormat->setInt32(kKeyHeight, 720); 1010 } 1011 // for MediaExtractor.CasInfo 1012 mFormat->setInt32(kKeyCASystemID, mCASystemId); 1013 mFormat->setData(kKeyCASessionID, 0, 1014 mCasSessionId.data(), mCasSessionId.size()); 1015 } 1016 return dequeueScrambledAccessUnit(); 1017 } 1018 1019 const uint8_t *data = mBuffer->data(); 1020 1021 size_t size = mBuffer->size(); 1022 Vector<NALPosition> nals; 1023 1024 size_t totalSize = 0; 1025 size_t seiCount = 0; 1026 1027 status_t err; 1028 const uint8_t *nalStart; 1029 size_t nalSize; 1030 bool foundSlice = false; 1031 bool foundIDR = false; 1032 1033 ALOGV("dequeueAccessUnit_H264[%d] %p/%zu", mAUIndex, data, size); 1034 1035 while ((err = getNextNALUnit(&data, &size, &nalStart, &nalSize)) == OK) { 1036 if (nalSize == 0) continue; 1037 1038 unsigned nalType = nalStart[0] & 0x1f; 1039 bool flush = false; 1040 1041 if (nalType == 1 || nalType == 5) { 1042 if (nalType == 5) { 1043 foundIDR = true; 1044 } 1045 if (foundSlice) { 1046 //TODO: Shouldn't this have been called with nalSize-1? 1047 ABitReader br(nalStart + 1, nalSize); 1048 unsigned first_mb_in_slice = parseUE(&br); 1049 1050 if (first_mb_in_slice == 0) { 1051 // This slice starts a new frame. 1052 1053 flush = true; 1054 } 1055 } 1056 1057 foundSlice = true; 1058 } else if ((nalType == 9 || nalType == 7) && foundSlice) { 1059 // Access unit delimiter and SPS will be associated with the 1060 // next frame. 1061 1062 flush = true; 1063 } else if (nalType == 6 && nalSize > 0) { 1064 // found non-zero sized SEI 1065 ++seiCount; 1066 } 1067 1068 if (flush) { 1069 // The access unit will contain all nal units up to, but excluding 1070 // the current one, separated by 0x00 0x00 0x00 0x01 startcodes. 1071 1072 size_t auSize = 4 * nals.size() + totalSize; 1073 sp<ABuffer> accessUnit = new ABuffer(auSize); 1074 sp<ABuffer> sei; 1075 1076 if (seiCount > 0) { 1077 sei = new ABuffer(seiCount * sizeof(NALPosition)); 1078 accessUnit->meta()->setBuffer("sei", sei); 1079 } 1080 1081#if !LOG_NDEBUG 1082 AString out; 1083#endif 1084 1085 size_t dstOffset = 0; 1086 size_t seiIndex = 0; 1087 size_t shrunkBytes = 0; 1088 for (size_t i = 0; i < nals.size(); ++i) { 1089 const NALPosition &pos = nals.itemAt(i); 1090 1091 unsigned nalType = mBuffer->data()[pos.nalOffset] & 0x1f; 1092 1093 if (nalType == 6 && pos.nalSize > 0) { 1094 if (seiIndex >= sei->size() / sizeof(NALPosition)) { 1095 ALOGE("Wrong seiIndex"); 1096 return NULL; 1097 } 1098 NALPosition &seiPos = ((NALPosition *)sei->data())[seiIndex++]; 1099 seiPos.nalOffset = dstOffset + 4; 1100 seiPos.nalSize = pos.nalSize; 1101 } 1102 1103#if !LOG_NDEBUG 1104 char tmp[128]; 1105 sprintf(tmp, "0x%02x", nalType); 1106 if (i > 0) { 1107 out.append(", "); 1108 } 1109 out.append(tmp); 1110#endif 1111 1112 memcpy(accessUnit->data() + dstOffset, "\x00\x00\x00\x01", 4); 1113 1114 if (mSampleDecryptor != NULL && (nalType == 1 || nalType == 5)) { 1115 uint8_t *nalData = mBuffer->data() + pos.nalOffset; 1116 size_t newSize = mSampleDecryptor->processNal(nalData, pos.nalSize); 1117 // Note: the data can shrink due to unescaping 1118 memcpy(accessUnit->data() + dstOffset + 4, 1119 nalData, 1120 newSize); 1121 dstOffset += newSize + 4; 1122 1123 size_t thisShrunkBytes = pos.nalSize - newSize; 1124 //ALOGV("dequeueAccessUnitH264[%d]: nalType: %d -> %zu (%zu)", 1125 // nalType, (int)pos.nalSize, newSize, thisShrunkBytes); 1126 1127 shrunkBytes += thisShrunkBytes; 1128 } 1129 else { 1130 memcpy(accessUnit->data() + dstOffset + 4, 1131 mBuffer->data() + pos.nalOffset, 1132 pos.nalSize); 1133 1134 dstOffset += pos.nalSize + 4; 1135 //ALOGV("dequeueAccessUnitH264 [%d] %d @%d", 1136 // nalType, (int)pos.nalSize, (int)pos.nalOffset); 1137 } 1138 } 1139 1140#if !LOG_NDEBUG 1141 ALOGV("accessUnit contains nal types %s", out.c_str()); 1142#endif 1143 1144 const NALPosition &pos = nals.itemAt(nals.size() - 1); 1145 size_t nextScan = pos.nalOffset + pos.nalSize; 1146 1147 memmove(mBuffer->data(), 1148 mBuffer->data() + nextScan, 1149 mBuffer->size() - nextScan); 1150 1151 mBuffer->setRange(0, mBuffer->size() - nextScan); 1152 1153 int64_t timeUs = fetchTimestamp(nextScan); 1154 if (timeUs < 0ll) { 1155 ALOGE("Negative timeUs"); 1156 return NULL; 1157 } 1158 1159 accessUnit->meta()->setInt64("timeUs", timeUs); 1160 if (foundIDR) { 1161 accessUnit->meta()->setInt32("isSync", 1); 1162 } 1163 1164 if (mFormat == NULL) { 1165 mFormat = MakeAVCCodecSpecificData(accessUnit); 1166 } 1167 1168 if (mSampleDecryptor != NULL && shrunkBytes > 0) { 1169 size_t adjustedSize = accessUnit->size() - shrunkBytes; 1170 ALOGV("dequeueAccessUnitH264[%d]: AU size adjusted %zu -> %zu", 1171 mAUIndex, accessUnit->size(), adjustedSize); 1172 accessUnit->setRange(0, adjustedSize); 1173 } 1174 1175 ALOGV("dequeueAccessUnitH264[%d]: AU %p(%zu) dstOffset:%zu, nals:%zu, totalSize:%zu ", 1176 mAUIndex, accessUnit->data(), accessUnit->size(), 1177 dstOffset, nals.size(), totalSize); 1178 mAUIndex++; 1179 1180 return accessUnit; 1181 } 1182 1183 NALPosition pos; 1184 pos.nalOffset = nalStart - mBuffer->data(); 1185 pos.nalSize = nalSize; 1186 1187 nals.push(pos); 1188 1189 totalSize += nalSize; 1190 } 1191 if (err != (status_t)-EAGAIN) { 1192 ALOGE("Unexpeted err"); 1193 return NULL; 1194 } 1195 1196 return NULL; 1197} 1198 1199sp<ABuffer> ElementaryStreamQueue::dequeueAccessUnitMPEGAudio() { 1200 const uint8_t *data = mBuffer->data(); 1201 size_t size = mBuffer->size(); 1202 1203 if (size < 4) { 1204 return NULL; 1205 } 1206 1207 uint32_t header = U32_AT(data); 1208 1209 size_t frameSize; 1210 int samplingRate, numChannels, bitrate, numSamples; 1211 if (!GetMPEGAudioFrameSize( 1212 header, &frameSize, &samplingRate, &numChannels, 1213 &bitrate, &numSamples)) { 1214 ALOGE("Failed to get audio frame size"); 1215 return NULL; 1216 } 1217 1218 if (size < frameSize) { 1219 return NULL; 1220 } 1221 1222 unsigned layer = 4 - ((header >> 17) & 3); 1223 1224 sp<ABuffer> accessUnit = new ABuffer(frameSize); 1225 memcpy(accessUnit->data(), data, frameSize); 1226 1227 memmove(mBuffer->data(), 1228 mBuffer->data() + frameSize, 1229 mBuffer->size() - frameSize); 1230 1231 mBuffer->setRange(0, mBuffer->size() - frameSize); 1232 1233 int64_t timeUs = fetchTimestamp(frameSize); 1234 if (timeUs < 0ll) { 1235 ALOGE("Negative timeUs"); 1236 return NULL; 1237 } 1238 1239 accessUnit->meta()->setInt64("timeUs", timeUs); 1240 accessUnit->meta()->setInt32("isSync", 1); 1241 1242 if (mFormat == NULL) { 1243 mFormat = new MetaData; 1244 1245 switch (layer) { 1246 case 1: 1247 mFormat->setCString( 1248 kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_MPEG_LAYER_I); 1249 break; 1250 case 2: 1251 mFormat->setCString( 1252 kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_MPEG_LAYER_II); 1253 break; 1254 case 3: 1255 mFormat->setCString( 1256 kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_MPEG); 1257 break; 1258 default: 1259 return NULL; 1260 } 1261 1262 mFormat->setInt32(kKeySampleRate, samplingRate); 1263 mFormat->setInt32(kKeyChannelCount, numChannels); 1264 } 1265 1266 return accessUnit; 1267} 1268 1269static void EncodeSize14(uint8_t **_ptr, size_t size) { 1270 if (size > 0x3fff) { 1271 ALOGE("Wrong size"); 1272 return; 1273 } 1274 1275 uint8_t *ptr = *_ptr; 1276 1277 *ptr++ = 0x80 | (size >> 7); 1278 *ptr++ = size & 0x7f; 1279 1280 *_ptr = ptr; 1281} 1282 1283static sp<ABuffer> MakeMPEGVideoESDS(const sp<ABuffer> &csd) { 1284 sp<ABuffer> esds = new ABuffer(csd->size() + 25); 1285 1286 uint8_t *ptr = esds->data(); 1287 *ptr++ = 0x03; 1288 EncodeSize14(&ptr, 22 + csd->size()); 1289 1290 *ptr++ = 0x00; // ES_ID 1291 *ptr++ = 0x00; 1292 1293 *ptr++ = 0x00; // streamDependenceFlag, URL_Flag, OCRstreamFlag 1294 1295 *ptr++ = 0x04; 1296 EncodeSize14(&ptr, 16 + csd->size()); 1297 1298 *ptr++ = 0x40; // Audio ISO/IEC 14496-3 1299 1300 for (size_t i = 0; i < 12; ++i) { 1301 *ptr++ = 0x00; 1302 } 1303 1304 *ptr++ = 0x05; 1305 EncodeSize14(&ptr, csd->size()); 1306 1307 memcpy(ptr, csd->data(), csd->size()); 1308 1309 return esds; 1310} 1311 1312sp<ABuffer> ElementaryStreamQueue::dequeueAccessUnitMPEGVideo() { 1313 if (isScrambled()) { 1314 if (mBuffer == NULL || mBuffer->size() == 0) { 1315 return NULL; 1316 } 1317 if (mFormat == NULL) { 1318 ALOGI("Creating dummy MPEG format for scrambled content"); 1319 mFormat = new MetaData; 1320 mFormat->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_MPEG2); 1321 mFormat->setInt32(kKeyWidth, 1280); 1322 mFormat->setInt32(kKeyHeight, 720); 1323 1324 // for MediaExtractor.CasInfo 1325 mFormat->setInt32(kKeyCASystemID, mCASystemId); 1326 mFormat->setData(kKeyCASessionID, 0, 1327 mCasSessionId.data(), mCasSessionId.size()); 1328 } 1329 return dequeueScrambledAccessUnit(); 1330 } 1331 1332 const uint8_t *data = mBuffer->data(); 1333 size_t size = mBuffer->size(); 1334 1335 Vector<size_t> userDataPositions; 1336 1337 bool sawPictureStart = false; 1338 int pprevStartCode = -1; 1339 int prevStartCode = -1; 1340 int currentStartCode = -1; 1341 bool gopFound = false; 1342 bool isClosedGop = false; 1343 bool brokenLink = false; 1344 1345 size_t offset = 0; 1346 while (offset + 3 < size) { 1347 if (memcmp(&data[offset], "\x00\x00\x01", 3)) { 1348 ++offset; 1349 continue; 1350 } 1351 1352 pprevStartCode = prevStartCode; 1353 prevStartCode = currentStartCode; 1354 currentStartCode = data[offset + 3]; 1355 1356 if (currentStartCode == 0xb3 && mFormat == NULL) { 1357 memmove(mBuffer->data(), mBuffer->data() + offset, size - offset); 1358 size -= offset; 1359 (void)fetchTimestamp(offset); 1360 offset = 0; 1361 mBuffer->setRange(0, size); 1362 } 1363 1364 if ((prevStartCode == 0xb3 && currentStartCode != 0xb5) 1365 || (pprevStartCode == 0xb3 && prevStartCode == 0xb5)) { 1366 // seqHeader without/with extension 1367 1368 if (mFormat == NULL) { 1369 if (size < 7u) { 1370 ALOGE("Size too small"); 1371 return NULL; 1372 } 1373 1374 unsigned width = 1375 (data[4] << 4) | data[5] >> 4; 1376 1377 unsigned height = 1378 ((data[5] & 0x0f) << 8) | data[6]; 1379 1380 mFormat = new MetaData; 1381 mFormat->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_MPEG2); 1382 mFormat->setInt32(kKeyWidth, width); 1383 mFormat->setInt32(kKeyHeight, height); 1384 1385 ALOGI("found MPEG2 video codec config (%d x %d)", width, height); 1386 1387 sp<ABuffer> csd = new ABuffer(offset); 1388 memcpy(csd->data(), data, offset); 1389 1390 memmove(mBuffer->data(), 1391 mBuffer->data() + offset, 1392 mBuffer->size() - offset); 1393 1394 mBuffer->setRange(0, mBuffer->size() - offset); 1395 size -= offset; 1396 (void)fetchTimestamp(offset); 1397 offset = 0; 1398 1399 // hexdump(csd->data(), csd->size()); 1400 1401 sp<ABuffer> esds = MakeMPEGVideoESDS(csd); 1402 mFormat->setData( 1403 kKeyESDS, kTypeESDS, esds->data(), esds->size()); 1404 1405 return NULL; 1406 } 1407 } 1408 1409 if (mFormat != NULL && currentStartCode == 0xb8) { 1410 // GOP layer 1411 if (offset + 7 >= size) { 1412 ALOGE("Size too small"); 1413 return NULL; 1414 } 1415 gopFound = true; 1416 isClosedGop = (data[offset + 7] & 0x40) != 0; 1417 brokenLink = (data[offset + 7] & 0x20) != 0; 1418 } 1419 1420 if (mFormat != NULL && currentStartCode == 0xb2) { 1421 userDataPositions.add(offset); 1422 } 1423 1424 if (mFormat != NULL && currentStartCode == 0x00) { 1425 // Picture start 1426 1427 if (!sawPictureStart) { 1428 sawPictureStart = true; 1429 } else { 1430 sp<ABuffer> accessUnit = new ABuffer(offset); 1431 memcpy(accessUnit->data(), data, offset); 1432 1433 memmove(mBuffer->data(), 1434 mBuffer->data() + offset, 1435 mBuffer->size() - offset); 1436 1437 mBuffer->setRange(0, mBuffer->size() - offset); 1438 1439 int64_t timeUs = fetchTimestamp(offset); 1440 if (timeUs < 0ll) { 1441 ALOGE("Negative timeUs"); 1442 return NULL; 1443 } 1444 1445 offset = 0; 1446 1447 accessUnit->meta()->setInt64("timeUs", timeUs); 1448 if (gopFound && (!brokenLink || isClosedGop)) { 1449 accessUnit->meta()->setInt32("isSync", 1); 1450 } 1451 1452 ALOGV("returning MPEG video access unit at time %" PRId64 " us", 1453 timeUs); 1454 1455 // hexdump(accessUnit->data(), accessUnit->size()); 1456 1457 if (userDataPositions.size() > 0) { 1458 sp<ABuffer> mpegUserData = 1459 new ABuffer(userDataPositions.size() * sizeof(size_t)); 1460 if (mpegUserData != NULL && mpegUserData->data() != NULL) { 1461 for (size_t i = 0; i < userDataPositions.size(); ++i) { 1462 memcpy( 1463 mpegUserData->data() + i * sizeof(size_t), 1464 &userDataPositions[i], sizeof(size_t)); 1465 } 1466 accessUnit->meta()->setBuffer("mpegUserData", mpegUserData); 1467 } 1468 } 1469 1470 return accessUnit; 1471 } 1472 } 1473 1474 ++offset; 1475 } 1476 1477 return NULL; 1478} 1479 1480static ssize_t getNextChunkSize( 1481 const uint8_t *data, size_t size) { 1482 static const char kStartCode[] = "\x00\x00\x01"; 1483 1484 if (size < 3) { 1485 return -EAGAIN; 1486 } 1487 1488 if (memcmp(kStartCode, data, 3)) { 1489 return -EAGAIN; 1490 } 1491 1492 size_t offset = 3; 1493 while (offset + 2 < size) { 1494 if (!memcmp(&data[offset], kStartCode, 3)) { 1495 return offset; 1496 } 1497 1498 ++offset; 1499 } 1500 1501 return -EAGAIN; 1502} 1503 1504sp<ABuffer> ElementaryStreamQueue::dequeueAccessUnitMPEG4Video() { 1505 uint8_t *data = mBuffer->data(); 1506 size_t size = mBuffer->size(); 1507 1508 enum { 1509 SKIP_TO_VISUAL_OBJECT_SEQ_START, 1510 EXPECT_VISUAL_OBJECT_START, 1511 EXPECT_VO_START, 1512 EXPECT_VOL_START, 1513 WAIT_FOR_VOP_START, 1514 SKIP_TO_VOP_START, 1515 1516 } state; 1517 1518 if (mFormat == NULL) { 1519 state = SKIP_TO_VISUAL_OBJECT_SEQ_START; 1520 } else { 1521 state = SKIP_TO_VOP_START; 1522 } 1523 1524 int32_t width = -1, height = -1; 1525 1526 size_t offset = 0; 1527 ssize_t chunkSize; 1528 while ((chunkSize = getNextChunkSize( 1529 &data[offset], size - offset)) > 0) { 1530 bool discard = false; 1531 1532 unsigned chunkType = data[offset + 3]; 1533 1534 switch (state) { 1535 case SKIP_TO_VISUAL_OBJECT_SEQ_START: 1536 { 1537 if (chunkType == 0xb0) { 1538 // Discard anything before this marker. 1539 1540 state = EXPECT_VISUAL_OBJECT_START; 1541 } else { 1542 discard = true; 1543 } 1544 break; 1545 } 1546 1547 case EXPECT_VISUAL_OBJECT_START: 1548 { 1549 if (chunkType != 0xb5) { 1550 ALOGE("Unexpected chunkType"); 1551 return NULL; 1552 } 1553 state = EXPECT_VO_START; 1554 break; 1555 } 1556 1557 case EXPECT_VO_START: 1558 { 1559 if (chunkType > 0x1f) { 1560 ALOGE("Unexpected chunkType"); 1561 return NULL; 1562 } 1563 state = EXPECT_VOL_START; 1564 break; 1565 } 1566 1567 case EXPECT_VOL_START: 1568 { 1569 if ((chunkType & 0xf0) != 0x20) { 1570 ALOGE("Wrong chunkType"); 1571 return NULL; 1572 } 1573 1574 if (!ExtractDimensionsFromVOLHeader( 1575 &data[offset], chunkSize, 1576 &width, &height)) { 1577 ALOGE("Failed to get dimension"); 1578 return NULL; 1579 } 1580 1581 state = WAIT_FOR_VOP_START; 1582 break; 1583 } 1584 1585 case WAIT_FOR_VOP_START: 1586 { 1587 if (chunkType == 0xb3 || chunkType == 0xb6) { 1588 // group of VOP or VOP start. 1589 1590 mFormat = new MetaData; 1591 mFormat->setCString( 1592 kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_MPEG4); 1593 1594 mFormat->setInt32(kKeyWidth, width); 1595 mFormat->setInt32(kKeyHeight, height); 1596 1597 ALOGI("found MPEG4 video codec config (%d x %d)", 1598 width, height); 1599 1600 sp<ABuffer> csd = new ABuffer(offset); 1601 memcpy(csd->data(), data, offset); 1602 1603 // hexdump(csd->data(), csd->size()); 1604 1605 sp<ABuffer> esds = MakeMPEGVideoESDS(csd); 1606 mFormat->setData( 1607 kKeyESDS, kTypeESDS, 1608 esds->data(), esds->size()); 1609 1610 discard = true; 1611 state = SKIP_TO_VOP_START; 1612 } 1613 1614 break; 1615 } 1616 1617 case SKIP_TO_VOP_START: 1618 { 1619 if (chunkType == 0xb6) { 1620 int vopCodingType = (data[offset + 4] & 0xc0) >> 6; 1621 1622 offset += chunkSize; 1623 1624 sp<ABuffer> accessUnit = new ABuffer(offset); 1625 memcpy(accessUnit->data(), data, offset); 1626 1627 memmove(data, &data[offset], size - offset); 1628 size -= offset; 1629 mBuffer->setRange(0, size); 1630 1631 int64_t timeUs = fetchTimestamp(offset); 1632 if (timeUs < 0ll) { 1633 ALOGE("Negative timeus"); 1634 return NULL; 1635 } 1636 1637 offset = 0; 1638 1639 accessUnit->meta()->setInt64("timeUs", timeUs); 1640 if (vopCodingType == 0) { // intra-coded VOP 1641 accessUnit->meta()->setInt32("isSync", 1); 1642 } 1643 1644 ALOGV("returning MPEG4 video access unit at time %" PRId64 " us", 1645 timeUs); 1646 1647 // hexdump(accessUnit->data(), accessUnit->size()); 1648 1649 return accessUnit; 1650 } else if (chunkType != 0xb3) { 1651 offset += chunkSize; 1652 discard = true; 1653 } 1654 1655 break; 1656 } 1657 1658 default: 1659 ALOGE("Unknown state: %d", state); 1660 return NULL; 1661 } 1662 1663 if (discard) { 1664 (void)fetchTimestamp(offset); 1665 memmove(data, &data[offset], size - offset); 1666 size -= offset; 1667 offset = 0; 1668 mBuffer->setRange(0, size); 1669 } else { 1670 offset += chunkSize; 1671 } 1672 } 1673 1674 return NULL; 1675} 1676 1677void ElementaryStreamQueue::signalEOS() { 1678 if (!mEOSReached) { 1679 if (mMode == MPEG_VIDEO) { 1680 const char *theEnd = "\x00\x00\x01\x00"; 1681 appendData(theEnd, 4, 0); 1682 } 1683 mEOSReached = true; 1684 } else { 1685 ALOGW("EOS already signaled"); 1686 } 1687} 1688 1689sp<ABuffer> ElementaryStreamQueue::dequeueAccessUnitMetadata() { 1690 size_t size = mBuffer->size(); 1691 if (!size) { 1692 return NULL; 1693 } 1694 1695 sp<ABuffer> accessUnit = new ABuffer(size); 1696 int64_t timeUs = fetchTimestamp(size); 1697 accessUnit->meta()->setInt64("timeUs", timeUs); 1698 1699 memcpy(accessUnit->data(), mBuffer->data(), size); 1700 mBuffer->setRange(0, 0); 1701 1702 if (mFormat == NULL) { 1703 mFormat = new MetaData; 1704 mFormat->setCString(kKeyMIMEType, MEDIA_MIMETYPE_DATA_TIMED_ID3); 1705 } 1706 1707 return accessUnit; 1708} 1709 1710void ElementaryStreamQueue::signalNewSampleAesKey(const sp<AMessage> &keyItem) { 1711 if (mSampleDecryptor == NULL) { 1712 ALOGE("signalNewSampleAesKey: Stream %x is not encrypted; keyItem: %p", 1713 mMode, keyItem.get()); 1714 return; 1715 } 1716 1717 mSampleDecryptor->signalNewSampleAesKey(keyItem); 1718} 1719 1720 1721} // namespace android 1722