1 /* 2 * Copyright (C) 2011 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 "MPEG2PSExtractor" 19 #include <utils/Log.h> 20 21 #include "MPEG2PSExtractor.h" 22 23 #include <AnotherPacketSource.h> 24 #include <ESQueue.h> 25 26 #include <media/stagefright/foundation/ABitReader.h> 27 #include <media/stagefright/foundation/ABuffer.h> 28 #include <media/stagefright/foundation/ADebug.h> 29 #include <media/stagefright/foundation/AMessage.h> 30 #include <media/stagefright/foundation/ByteUtils.h> 31 #include <media/stagefright/foundation/hexdump.h> 32 #include <media/stagefright/MediaDefs.h> 33 #include <media/stagefright/MediaErrors.h> 34 #include <media/stagefright/MetaData.h> 35 #include <media/stagefright/Utils.h> 36 #include <utils/String8.h> 37 38 #include <inttypes.h> 39 40 namespace android { 41 42 struct MPEG2PSExtractor::Track : public MediaTrackHelper { 43 Track(MPEG2PSExtractor *extractor, 44 unsigned stream_id, unsigned stream_type); 45 46 virtual media_status_t start(); 47 virtual media_status_t stop(); 48 virtual media_status_t getFormat(AMediaFormat *); 49 50 virtual media_status_t read( 51 MediaBufferHelper **buffer, const ReadOptions *options); 52 53 protected: 54 virtual ~Track(); 55 56 private: 57 friend struct MPEG2PSExtractor; 58 59 MPEG2PSExtractor *mExtractor; 60 61 unsigned mStreamID; 62 unsigned mStreamType; 63 ElementaryStreamQueue *mQueue; 64 sp<AnotherPacketSource> mSource; 65 66 status_t appendPESData( 67 unsigned PTS_DTS_flags, 68 uint64_t PTS, uint64_t DTS, 69 const uint8_t *data, size_t size); 70 71 DISALLOW_EVIL_CONSTRUCTORS(Track); 72 }; 73 74 struct MPEG2PSExtractor::WrappedTrack : public MediaTrackHelper { 75 WrappedTrack(MPEG2PSExtractor *extractor, Track *track); 76 77 virtual media_status_t start(); 78 virtual media_status_t stop(); 79 virtual media_status_t getFormat(AMediaFormat *); 80 81 virtual media_status_t read( 82 MediaBufferHelper **buffer, const ReadOptions *options); 83 84 protected: 85 virtual ~WrappedTrack(); 86 87 private: 88 MPEG2PSExtractor *mExtractor; 89 MPEG2PSExtractor::Track *mTrack; 90 91 DISALLOW_EVIL_CONSTRUCTORS(WrappedTrack); 92 }; 93 94 //////////////////////////////////////////////////////////////////////////////// 95 96 MPEG2PSExtractor::MPEG2PSExtractor(DataSourceHelper *source) 97 : mDataSource(source), 98 mOffset(0), 99 mFinalResult(OK), 100 mBuffer(new ABuffer(0)), 101 mScanning(true), 102 mProgramStreamMapValid(false) { 103 for (size_t i = 0; i < 500; ++i) { 104 if (feedMore() != OK) { 105 break; 106 } 107 } 108 109 // Remove all tracks that were unable to determine their format. 110 AMediaFormat *meta = AMediaFormat_new(); 111 for (size_t i = mTracks.size(); i > 0;) { 112 i--; 113 Track *track = mTracks.valueAt(i); 114 if (track->getFormat(meta) != AMEDIA_OK) { 115 mTracks.removeItemsAt(i); 116 delete track; 117 } 118 } 119 AMediaFormat_delete(meta); 120 121 mScanning = false; 122 } 123 124 MPEG2PSExtractor::~MPEG2PSExtractor() { 125 delete mDataSource; 126 for (size_t i = mTracks.size(); i > 0;) { 127 i--; 128 delete mTracks.valueAt(i); 129 } 130 } 131 132 size_t MPEG2PSExtractor::countTracks() { 133 return mTracks.size(); 134 } 135 136 MediaTrackHelper *MPEG2PSExtractor::getTrack(size_t index) { 137 if (index >= mTracks.size()) { 138 return NULL; 139 } 140 141 return new WrappedTrack(this, mTracks.valueAt(index)); 142 } 143 144 media_status_t MPEG2PSExtractor::getTrackMetaData( 145 AMediaFormat *meta, 146 size_t index, uint32_t /* flags */) { 147 if (index >= mTracks.size()) { 148 return AMEDIA_ERROR_UNKNOWN; 149 } 150 151 return mTracks.valueAt(index)->getFormat(meta); 152 } 153 154 media_status_t MPEG2PSExtractor::getMetaData(AMediaFormat *meta) { 155 AMediaFormat_setString(meta, AMEDIAFORMAT_KEY_MIME, MEDIA_MIMETYPE_CONTAINER_MPEG2PS); 156 157 return AMEDIA_OK; 158 } 159 160 uint32_t MPEG2PSExtractor::flags() const { 161 return CAN_PAUSE; 162 } 163 164 status_t MPEG2PSExtractor::feedMore() { 165 Mutex::Autolock autoLock(mLock); 166 167 // How much data we're reading at a time 168 static const size_t kChunkSize = 8192; 169 170 for (;;) { 171 status_t err = dequeueChunk(); 172 173 if (err == -EAGAIN && mFinalResult == OK) { 174 memmove(mBuffer->base(), mBuffer->data(), mBuffer->size()); 175 mBuffer->setRange(0, mBuffer->size()); 176 177 if (mBuffer->size() + kChunkSize > mBuffer->capacity()) { 178 size_t newCapacity = mBuffer->capacity() + kChunkSize; 179 sp<ABuffer> newBuffer = new ABuffer(newCapacity); 180 memcpy(newBuffer->data(), mBuffer->data(), mBuffer->size()); 181 newBuffer->setRange(0, mBuffer->size()); 182 mBuffer = newBuffer; 183 } 184 185 ssize_t n = mDataSource->readAt( 186 mOffset, mBuffer->data() + mBuffer->size(), kChunkSize); 187 188 if (n < (ssize_t)kChunkSize) { 189 mFinalResult = (n < 0) ? (status_t)n : ERROR_END_OF_STREAM; 190 return mFinalResult; 191 } 192 193 mBuffer->setRange(mBuffer->offset(), mBuffer->size() + n); 194 mOffset += n; 195 } else if (err != OK) { 196 mFinalResult = err; 197 return err; 198 } else { 199 return OK; 200 } 201 } 202 } 203 204 status_t MPEG2PSExtractor::dequeueChunk() { 205 if (mBuffer->size() < 4) { 206 return -EAGAIN; 207 } 208 209 if (memcmp("\x00\x00\x01", mBuffer->data(), 3)) { 210 return ERROR_MALFORMED; 211 } 212 213 unsigned chunkType = mBuffer->data()[3]; 214 215 ssize_t res; 216 217 switch (chunkType) { 218 case 0xba: 219 { 220 res = dequeuePack(); 221 break; 222 } 223 224 case 0xbb: 225 { 226 res = dequeueSystemHeader(); 227 break; 228 } 229 230 default: 231 { 232 res = dequeuePES(); 233 break; 234 } 235 } 236 237 if (res > 0) { 238 if (mBuffer->size() < (size_t)res) { 239 return -EAGAIN; 240 } 241 242 mBuffer->setRange(mBuffer->offset() + res, mBuffer->size() - res); 243 res = OK; 244 } 245 246 return res; 247 } 248 249 ssize_t MPEG2PSExtractor::dequeuePack() { 250 // 32 + 2 + 3 + 1 + 15 + 1 + 15+ 1 + 9 + 1 + 22 + 1 + 1 | +5 251 252 if (mBuffer->size() < 14) { 253 return -EAGAIN; 254 } 255 256 unsigned pack_stuffing_length = mBuffer->data()[13] & 7; 257 258 return pack_stuffing_length + 14; 259 } 260 261 ssize_t MPEG2PSExtractor::dequeueSystemHeader() { 262 if (mBuffer->size() < 6) { 263 return -EAGAIN; 264 } 265 266 unsigned header_length = U16_AT(mBuffer->data() + 4); 267 268 return header_length + 6; 269 } 270 271 ssize_t MPEG2PSExtractor::dequeuePES() { 272 if (mBuffer->size() < 6) { 273 return -EAGAIN; 274 } 275 276 unsigned PES_packet_length = U16_AT(mBuffer->data() + 4); 277 if (PES_packet_length == 0u) { 278 ALOGE("PES_packet_length is 0"); 279 return -EAGAIN; 280 } 281 282 size_t n = PES_packet_length + 6; 283 284 if (mBuffer->size() < n) { 285 return -EAGAIN; 286 } 287 288 ABitReader br(mBuffer->data(), n); 289 290 unsigned packet_startcode_prefix = br.getBits(24); 291 292 ALOGV("packet_startcode_prefix = 0x%08x", packet_startcode_prefix); 293 294 if (packet_startcode_prefix != 1) { 295 ALOGV("Supposedly payload_unit_start=1 unit does not start " 296 "with startcode."); 297 298 return ERROR_MALFORMED; 299 } 300 301 if (packet_startcode_prefix != 0x000001u) { 302 ALOGE("Wrong PES prefix"); 303 return ERROR_MALFORMED; 304 } 305 306 unsigned stream_id = br.getBits(8); 307 ALOGV("stream_id = 0x%02x", stream_id); 308 309 /* unsigned PES_packet_length = */br.getBits(16); 310 311 if (stream_id == 0xbc) { 312 // program_stream_map 313 314 if (!mScanning) { 315 return n; 316 } 317 318 mStreamTypeByESID.clear(); 319 320 /* unsigned current_next_indicator = */br.getBits(1); 321 /* unsigned reserved = */br.getBits(2); 322 /* unsigned program_stream_map_version = */br.getBits(5); 323 /* unsigned reserved = */br.getBits(7); 324 /* unsigned marker_bit = */br.getBits(1); 325 unsigned program_stream_info_length = br.getBits(16); 326 327 size_t offset = 0; 328 while (offset < program_stream_info_length) { 329 if (offset + 2 > program_stream_info_length) { 330 return ERROR_MALFORMED; 331 } 332 333 unsigned descriptor_tag = br.getBits(8); 334 unsigned descriptor_length = br.getBits(8); 335 336 ALOGI("found descriptor tag 0x%02x of length %u", 337 descriptor_tag, descriptor_length); 338 339 if (offset + 2 + descriptor_length > program_stream_info_length) { 340 return ERROR_MALFORMED; 341 } 342 343 br.skipBits(8 * descriptor_length); 344 345 offset += 2 + descriptor_length; 346 } 347 348 unsigned elementary_stream_map_length = br.getBits(16); 349 350 offset = 0; 351 while (offset < elementary_stream_map_length) { 352 if (offset + 4 > elementary_stream_map_length) { 353 return ERROR_MALFORMED; 354 } 355 356 unsigned stream_type = br.getBits(8); 357 unsigned elementary_stream_id = br.getBits(8); 358 359 ALOGI("elementary stream id 0x%02x has stream type 0x%02x", 360 elementary_stream_id, stream_type); 361 362 mStreamTypeByESID.add(elementary_stream_id, stream_type); 363 364 unsigned elementary_stream_info_length = br.getBits(16); 365 366 if (offset + 4 + elementary_stream_info_length 367 > elementary_stream_map_length) { 368 return ERROR_MALFORMED; 369 } 370 371 offset += 4 + elementary_stream_info_length; 372 } 373 374 /* unsigned CRC32 = */br.getBits(32); 375 376 mProgramStreamMapValid = true; 377 } else if (stream_id != 0xbe // padding_stream 378 && stream_id != 0xbf // private_stream_2 379 && stream_id != 0xf0 // ECM 380 && stream_id != 0xf1 // EMM 381 && stream_id != 0xff // program_stream_directory 382 && stream_id != 0xf2 // DSMCC 383 && stream_id != 0xf8) { // H.222.1 type E 384 /* unsigned PES_marker_bits = */br.getBits(2); // should be 0x2(hex) 385 /* unsigned PES_scrambling_control = */br.getBits(2); 386 /* unsigned PES_priority = */br.getBits(1); 387 /* unsigned data_alignment_indicator = */br.getBits(1); 388 /* unsigned copyright = */br.getBits(1); 389 /* unsigned original_or_copy = */br.getBits(1); 390 391 unsigned PTS_DTS_flags = br.getBits(2); 392 ALOGV("PTS_DTS_flags = %u", PTS_DTS_flags); 393 394 unsigned ESCR_flag = br.getBits(1); 395 ALOGV("ESCR_flag = %u", ESCR_flag); 396 397 unsigned ES_rate_flag = br.getBits(1); 398 ALOGV("ES_rate_flag = %u", ES_rate_flag); 399 400 unsigned DSM_trick_mode_flag = br.getBits(1); 401 ALOGV("DSM_trick_mode_flag = %u", DSM_trick_mode_flag); 402 403 unsigned additional_copy_info_flag = br.getBits(1); 404 ALOGV("additional_copy_info_flag = %u", additional_copy_info_flag); 405 406 /* unsigned PES_CRC_flag = */br.getBits(1); 407 /* PES_extension_flag = */br.getBits(1); 408 409 unsigned PES_header_data_length = br.getBits(8); 410 ALOGV("PES_header_data_length = %u", PES_header_data_length); 411 412 unsigned optional_bytes_remaining = PES_header_data_length; 413 414 uint64_t PTS = 0, DTS = 0; 415 416 if (PTS_DTS_flags == 2 || PTS_DTS_flags == 3) { 417 if (optional_bytes_remaining < 5u) { 418 return ERROR_MALFORMED; 419 } 420 421 if (br.getBits(4) != PTS_DTS_flags) { 422 return ERROR_MALFORMED; 423 } 424 425 PTS = ((uint64_t)br.getBits(3)) << 30; 426 if (br.getBits(1) != 1u) { 427 return ERROR_MALFORMED; 428 } 429 PTS |= ((uint64_t)br.getBits(15)) << 15; 430 if (br.getBits(1) != 1u) { 431 return ERROR_MALFORMED; 432 } 433 PTS |= br.getBits(15); 434 if (br.getBits(1) != 1u) { 435 return ERROR_MALFORMED; 436 } 437 438 ALOGV("PTS = %" PRIu64, PTS); 439 // ALOGI("PTS = %.2f secs", PTS / 90000.0f); 440 441 optional_bytes_remaining -= 5; 442 443 if (PTS_DTS_flags == 3) { 444 if (optional_bytes_remaining < 5u) { 445 return ERROR_MALFORMED; 446 } 447 448 if (br.getBits(4) != 1u) { 449 return ERROR_MALFORMED; 450 } 451 452 DTS = ((uint64_t)br.getBits(3)) << 30; 453 if (br.getBits(1) != 1u) { 454 return ERROR_MALFORMED; 455 } 456 DTS |= ((uint64_t)br.getBits(15)) << 15; 457 if (br.getBits(1) != 1u) { 458 return ERROR_MALFORMED; 459 } 460 DTS |= br.getBits(15); 461 if (br.getBits(1) != 1u) { 462 return ERROR_MALFORMED; 463 } 464 465 ALOGV("DTS = %" PRIu64, DTS); 466 467 optional_bytes_remaining -= 5; 468 } 469 } 470 471 if (ESCR_flag) { 472 if (optional_bytes_remaining < 6u) { 473 return ERROR_MALFORMED; 474 } 475 476 br.getBits(2); 477 478 uint64_t ESCR = ((uint64_t)br.getBits(3)) << 30; 479 if (br.getBits(1) != 1u) { 480 return ERROR_MALFORMED; 481 } 482 ESCR |= ((uint64_t)br.getBits(15)) << 15; 483 if (br.getBits(1) != 1u) { 484 return ERROR_MALFORMED; 485 } 486 ESCR |= br.getBits(15); 487 if (br.getBits(1) != 1u) { 488 return ERROR_MALFORMED; 489 } 490 491 ALOGV("ESCR = %" PRIu64, ESCR); 492 /* unsigned ESCR_extension = */br.getBits(9); 493 494 if (br.getBits(1) != 1u) { 495 return ERROR_MALFORMED; 496 } 497 498 optional_bytes_remaining -= 6; 499 } 500 501 if (ES_rate_flag) { 502 if (optional_bytes_remaining < 3u) { 503 return ERROR_MALFORMED; 504 } 505 506 if (br.getBits(1) != 1u) { 507 return ERROR_MALFORMED; 508 } 509 /* unsigned ES_rate = */br.getBits(22); 510 if (br.getBits(1) != 1u) { 511 return ERROR_MALFORMED; 512 } 513 514 optional_bytes_remaining -= 3; 515 } 516 517 if (br.numBitsLeft() < optional_bytes_remaining * 8) { 518 return ERROR_MALFORMED; 519 } 520 521 br.skipBits(optional_bytes_remaining * 8); 522 523 // ES data follows. 524 525 if (PES_packet_length < PES_header_data_length + 3) { 526 return ERROR_MALFORMED; 527 } 528 529 unsigned dataLength = 530 PES_packet_length - 3 - PES_header_data_length; 531 532 if (br.numBitsLeft() < dataLength * 8) { 533 ALOGE("PES packet does not carry enough data to contain " 534 "payload. (numBitsLeft = %zu, required = %u)", 535 br.numBitsLeft(), dataLength * 8); 536 537 return ERROR_MALFORMED; 538 } 539 540 if (br.numBitsLeft() < dataLength * 8) { 541 return ERROR_MALFORMED; 542 } 543 544 ssize_t index = mTracks.indexOfKey(stream_id); 545 if (index < 0 && mScanning) { 546 unsigned streamType; 547 548 ssize_t streamTypeIndex; 549 if (mProgramStreamMapValid 550 && (streamTypeIndex = 551 mStreamTypeByESID.indexOfKey(stream_id)) >= 0) { 552 streamType = mStreamTypeByESID.valueAt(streamTypeIndex); 553 } else if ((stream_id & ~0x1f) == 0xc0) { 554 // ISO/IEC 13818-3 or ISO/IEC 11172-3 or ISO/IEC 13818-7 555 // or ISO/IEC 14496-3 audio 556 streamType = ATSParser::STREAMTYPE_MPEG2_AUDIO; 557 } else if ((stream_id & ~0x0f) == 0xe0) { 558 // ISO/IEC 13818-2 or ISO/IEC 11172-2 or ISO/IEC 14496-2 video 559 streamType = ATSParser::STREAMTYPE_MPEG2_VIDEO; 560 } else { 561 streamType = ATSParser::STREAMTYPE_RESERVED; 562 } 563 564 index = mTracks.add( 565 stream_id, new Track(this, stream_id, streamType)); 566 } 567 568 status_t err = OK; 569 570 if (index >= 0) { 571 err = 572 mTracks.editValueAt(index)->appendPESData( 573 PTS_DTS_flags, PTS, DTS, br.data(), dataLength); 574 } 575 576 br.skipBits(dataLength * 8); 577 578 if (err != OK) { 579 return err; 580 } 581 } else if (stream_id == 0xbe) { // padding_stream 582 if (PES_packet_length == 0u) { 583 return ERROR_MALFORMED; 584 } 585 br.skipBits(PES_packet_length * 8); 586 } else { 587 if (PES_packet_length == 0u) { 588 return ERROR_MALFORMED; 589 } 590 br.skipBits(PES_packet_length * 8); 591 } 592 593 return n; 594 } 595 596 //////////////////////////////////////////////////////////////////////////////// 597 598 MPEG2PSExtractor::Track::Track( 599 MPEG2PSExtractor *extractor, unsigned stream_id, unsigned stream_type) 600 : mExtractor(extractor), 601 mStreamID(stream_id), 602 mStreamType(stream_type), 603 mQueue(NULL) { 604 bool supported = true; 605 ElementaryStreamQueue::Mode mode; 606 607 switch (mStreamType) { 608 case ATSParser::STREAMTYPE_H264: 609 mode = ElementaryStreamQueue::H264; 610 break; 611 case ATSParser::STREAMTYPE_MPEG2_AUDIO_ADTS: 612 mode = ElementaryStreamQueue::AAC; 613 break; 614 case ATSParser::STREAMTYPE_MPEG1_AUDIO: 615 case ATSParser::STREAMTYPE_MPEG2_AUDIO: 616 mode = ElementaryStreamQueue::MPEG_AUDIO; 617 break; 618 619 case ATSParser::STREAMTYPE_MPEG1_VIDEO: 620 case ATSParser::STREAMTYPE_MPEG2_VIDEO: 621 mode = ElementaryStreamQueue::MPEG_VIDEO; 622 break; 623 624 case ATSParser::STREAMTYPE_MPEG4_VIDEO: 625 mode = ElementaryStreamQueue::MPEG4_VIDEO; 626 break; 627 628 default: 629 supported = false; 630 break; 631 } 632 633 if (supported) { 634 mQueue = new ElementaryStreamQueue(mode); 635 } else { 636 ALOGI("unsupported stream ID 0x%02x", stream_id); 637 } 638 } 639 640 MPEG2PSExtractor::Track::~Track() { 641 delete mQueue; 642 mQueue = NULL; 643 } 644 645 media_status_t MPEG2PSExtractor::Track::start() { 646 if (mSource == NULL) { 647 return AMEDIA_ERROR_UNKNOWN; 648 } 649 650 // initialize with one small buffer, but allow growth 651 mBufferGroup->init(1 /* one buffer */, 256 /* buffer size */, 64 /* max number of buffers */); 652 653 if (mSource->start(NULL) == OK) { // AnotherPacketSource::start doesn't use its argument 654 return AMEDIA_OK; 655 } 656 return AMEDIA_ERROR_UNKNOWN; 657 } 658 659 media_status_t MPEG2PSExtractor::Track::stop() { 660 if (mSource == NULL) { 661 return AMEDIA_ERROR_UNKNOWN; 662 } 663 664 if (mSource->stop() == OK) { 665 return AMEDIA_OK; 666 } 667 return AMEDIA_ERROR_UNKNOWN; 668 } 669 670 void copyAMessageToAMediaFormat(AMediaFormat *format, sp<AMessage> msg); 671 672 media_status_t MPEG2PSExtractor::Track::getFormat(AMediaFormat *meta) { 673 if (mSource == NULL) { 674 return AMEDIA_ERROR_UNKNOWN; 675 } 676 677 sp<MetaData> sourceMeta = mSource->getFormat(); 678 sp<AMessage> msg; 679 convertMetaDataToMessage(sourceMeta, &msg); 680 copyAMessageToAMediaFormat(meta, msg); 681 return AMEDIA_OK; 682 } 683 684 media_status_t MPEG2PSExtractor::Track::read( 685 MediaBufferHelper **buffer, const ReadOptions *options) { 686 if (mSource == NULL) { 687 return AMEDIA_ERROR_UNKNOWN; 688 } 689 690 status_t finalResult; 691 while (!mSource->hasBufferAvailable(&finalResult)) { 692 if (finalResult != OK) { 693 return AMEDIA_ERROR_END_OF_STREAM; 694 } 695 696 status_t err = mExtractor->feedMore(); 697 698 if (err != OK) { 699 mSource->signalEOS(err); 700 } 701 } 702 703 MediaBufferBase *mbuf; 704 mSource->read(&mbuf, (MediaTrack::ReadOptions*) options); 705 size_t length = mbuf->range_length(); 706 MediaBufferHelper *outbuf; 707 mBufferGroup->acquire_buffer(&outbuf, false, length); 708 memcpy(outbuf->data(), mbuf->data(), length); 709 outbuf->set_range(0, length); 710 *buffer = outbuf; 711 MetaDataBase &inMeta = mbuf->meta_data(); 712 AMediaFormat *outMeta = outbuf->meta_data(); 713 int64_t val64; 714 if (inMeta.findInt64(kKeyTime, &val64)) { 715 AMediaFormat_setInt64(outMeta, AMEDIAFORMAT_KEY_TIME_US, val64); 716 } 717 int32_t val32; 718 if (inMeta.findInt32(kKeyIsSyncFrame, &val32)) { 719 AMediaFormat_setInt32(outMeta, AMEDIAFORMAT_KEY_IS_SYNC_FRAME, val32); 720 } 721 if (inMeta.findInt32(kKeyCryptoMode, &val32)) { 722 AMediaFormat_setInt32(outMeta, AMEDIAFORMAT_KEY_CRYPTO_MODE, val32); 723 } 724 uint32_t bufType; 725 const void *bufData; 726 size_t bufSize; 727 if (inMeta.findData(kKeyCryptoIV, &bufType, &bufData, &bufSize)) { 728 AMediaFormat_setBuffer(outMeta, AMEDIAFORMAT_KEY_CRYPTO_IV, bufData, bufSize); 729 } 730 if (inMeta.findData(kKeyCryptoKey, &bufType, &bufData, &bufSize)) { 731 AMediaFormat_setBuffer(outMeta, AMEDIAFORMAT_KEY_CRYPTO_KEY, bufData, bufSize); 732 } 733 if (inMeta.findData(kKeyPlainSizes, &bufType, &bufData, &bufSize)) { 734 AMediaFormat_setBuffer(outMeta, AMEDIAFORMAT_KEY_CRYPTO_PLAIN_SIZES, bufData, bufSize); 735 } 736 if (inMeta.findData(kKeyEncryptedSizes, &bufType, &bufData, &bufSize)) { 737 AMediaFormat_setBuffer(outMeta, AMEDIAFORMAT_KEY_CRYPTO_ENCRYPTED_SIZES, bufData, bufSize); 738 } 739 if (inMeta.findData(kKeySEI, &bufType, &bufData, &bufSize)) { 740 AMediaFormat_setBuffer(outMeta, AMEDIAFORMAT_KEY_SEI, bufData, bufSize); 741 } 742 if (inMeta.findData(kKeyAudioPresentationInfo, &bufType, &bufData, &bufSize)) { 743 AMediaFormat_setBuffer(outMeta, AMEDIAFORMAT_KEY_AUDIO_PRESENTATION_INFO, bufData, bufSize); 744 } 745 mbuf->release(); 746 return AMEDIA_OK; 747 } 748 749 status_t MPEG2PSExtractor::Track::appendPESData( 750 unsigned PTS_DTS_flags, 751 uint64_t PTS, uint64_t /* DTS */, 752 const uint8_t *data, size_t size) { 753 if (mQueue == NULL) { 754 return OK; 755 } 756 757 int64_t timeUs; 758 if (PTS_DTS_flags == 2 || PTS_DTS_flags == 3) { 759 timeUs = (PTS * 100) / 9; 760 } else { 761 timeUs = 0; 762 } 763 764 status_t err = mQueue->appendData(data, size, timeUs); 765 766 if (err != OK) { 767 return err; 768 } 769 770 sp<ABuffer> accessUnit; 771 while ((accessUnit = mQueue->dequeueAccessUnit()) != NULL) { 772 if (mSource == NULL) { 773 sp<MetaData> meta = mQueue->getFormat(); 774 775 if (meta != NULL) { 776 ALOGV("Stream ID 0x%02x now has data.", mStreamID); 777 778 mSource = new AnotherPacketSource(meta); 779 mSource->queueAccessUnit(accessUnit); 780 } 781 } else if (mQueue->getFormat() != NULL) { 782 mSource->queueAccessUnit(accessUnit); 783 } 784 } 785 786 return OK; 787 } 788 789 //////////////////////////////////////////////////////////////////////////////// 790 791 MPEG2PSExtractor::WrappedTrack::WrappedTrack( 792 MPEG2PSExtractor *extractor, Track *track) 793 : mExtractor(extractor), 794 mTrack(track) { 795 } 796 797 MPEG2PSExtractor::WrappedTrack::~WrappedTrack() { 798 } 799 800 media_status_t MPEG2PSExtractor::WrappedTrack::start() { 801 delete mTrack->mBufferGroup; 802 mTrack->mBufferGroup = mBufferGroup; 803 mBufferGroup = nullptr; 804 return mTrack->start(); 805 } 806 807 media_status_t MPEG2PSExtractor::WrappedTrack::stop() { 808 return mTrack->stop(); 809 } 810 811 media_status_t MPEG2PSExtractor::WrappedTrack::getFormat(AMediaFormat *meta) { 812 return mTrack->getFormat(meta); 813 } 814 815 media_status_t MPEG2PSExtractor::WrappedTrack::read( 816 MediaBufferHelper **buffer, const ReadOptions *options) { 817 return mTrack->read(buffer, options); 818 } 819 820 //////////////////////////////////////////////////////////////////////////////// 821 822 bool SniffMPEG2PS( 823 DataSourceHelper *source, float *confidence) { 824 uint8_t header[5]; 825 if (source->readAt(0, header, sizeof(header)) < (ssize_t)sizeof(header)) { 826 return false; 827 } 828 829 if (memcmp("\x00\x00\x01\xba", header, 4) || (header[4] >> 6) != 1) { 830 return false; 831 } 832 833 *confidence = 0.25f; // Slightly larger than .mp3 extractor's confidence 834 835 return true; 836 } 837 838 } // namespace android 839