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
MPEG2PSExtractor(DataSourceHelper * source)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
~MPEG2PSExtractor()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
countTracks()132 size_t MPEG2PSExtractor::countTracks() {
133 return mTracks.size();
134 }
135
getTrack(size_t index)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
getTrackMetaData(AMediaFormat * meta,size_t index,uint32_t)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
getMetaData(AMediaFormat * meta)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
flags() const160 uint32_t MPEG2PSExtractor::flags() const {
161 return CAN_PAUSE;
162 }
163
feedMore()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
dequeueChunk()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
dequeuePack()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
dequeueSystemHeader()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
dequeuePES()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
Track(MPEG2PSExtractor * extractor,unsigned stream_id,unsigned stream_type)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
~Track()640 MPEG2PSExtractor::Track::~Track() {
641 delete mQueue;
642 mQueue = NULL;
643 }
644
start()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
stop()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
getFormat(AMediaFormat * meta)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
read(MediaBufferHelper ** buffer,const ReadOptions * options)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
appendPESData(unsigned PTS_DTS_flags,uint64_t PTS,uint64_t,const uint8_t * data,size_t size)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
WrappedTrack(MPEG2PSExtractor * extractor,Track * track)791 MPEG2PSExtractor::WrappedTrack::WrappedTrack(
792 MPEG2PSExtractor *extractor, Track *track)
793 : mExtractor(extractor),
794 mTrack(track) {
795 }
796
~WrappedTrack()797 MPEG2PSExtractor::WrappedTrack::~WrappedTrack() {
798 }
799
start()800 media_status_t MPEG2PSExtractor::WrappedTrack::start() {
801 delete mTrack->mBufferGroup;
802 mTrack->mBufferGroup = mBufferGroup;
803 mBufferGroup = nullptr;
804 return mTrack->start();
805 }
806
stop()807 media_status_t MPEG2PSExtractor::WrappedTrack::stop() {
808 return mTrack->stop();
809 }
810
getFormat(AMediaFormat * meta)811 media_status_t MPEG2PSExtractor::WrappedTrack::getFormat(AMediaFormat *meta) {
812 return mTrack->getFormat(meta);
813 }
814
read(MediaBufferHelper ** buffer,const ReadOptions * options)815 media_status_t MPEG2PSExtractor::WrappedTrack::read(
816 MediaBufferHelper **buffer, const ReadOptions *options) {
817 return mTrack->read(buffer, options);
818 }
819
820 ////////////////////////////////////////////////////////////////////////////////
821
SniffMPEG2PS(DataSourceHelper * source,float * confidence)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