• Home
  • History
  • Annotate
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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