rk3588-game
/
android13
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
android13/frameworks/av/media/extractors/mpeg2/MPEG2PSExtractor.cpp

838 lines
24 KiB
C++
Raw Blame History

/*
* Copyright (C) 2011 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
//#define LOG_NDEBUG 0
#define LOG_TAG "MPEG2PSExtractor"
#include <utils/Log.h>
#include "MPEG2PSExtractor.h"
#include <media/stagefright/foundation/ABitReader.h>
#include <media/stagefright/foundation/ABuffer.h>
#include <media/stagefright/foundation/ADebug.h>
#include <media/stagefright/foundation/AMessage.h>
#include <media/stagefright/foundation/ByteUtils.h>
#include <media/stagefright/foundation/hexdump.h>
#include <media/stagefright/MediaDefs.h>
#include <media/stagefright/MediaErrors.h>
#include <media/stagefright/MetaData.h>
#include <media/stagefright/Utils.h>
#include <mpeg2ts/AnotherPacketSource.h>
#include <mpeg2ts/ESQueue.h>
#include <utils/String8.h>
#include <inttypes.h>
namespace android {
struct MPEG2PSExtractor::Track : public MediaTrackHelper {
Track(MPEG2PSExtractor *extractor,
unsigned stream_id, unsigned stream_type);
virtual media_status_t start();
virtual media_status_t stop();
virtual media_status_t getFormat(AMediaFormat *);
virtual media_status_t read(
MediaBufferHelper **buffer, const ReadOptions *options);
protected:
virtual ~Track();
private:
friend struct MPEG2PSExtractor;
MPEG2PSExtractor *mExtractor;
unsigned mStreamID;
unsigned mStreamType;
ElementaryStreamQueue *mQueue;
sp<AnotherPacketSource> mSource;
status_t appendPESData(
unsigned PTS_DTS_flags,
uint64_t PTS, uint64_t DTS,
const uint8_t *data, size_t size);
DISALLOW_EVIL_CONSTRUCTORS(Track);
};
struct MPEG2PSExtractor::WrappedTrack : public MediaTrackHelper {
WrappedTrack(MPEG2PSExtractor *extractor, Track *track);
virtual media_status_t start();
virtual media_status_t stop();
virtual media_status_t getFormat(AMediaFormat *);
virtual media_status_t read(
MediaBufferHelper **buffer, const ReadOptions *options);
protected:
virtual ~WrappedTrack();
private:
MPEG2PSExtractor *mExtractor;
MPEG2PSExtractor::Track *mTrack;
DISALLOW_EVIL_CONSTRUCTORS(WrappedTrack);
};
////////////////////////////////////////////////////////////////////////////////
MPEG2PSExtractor::MPEG2PSExtractor(DataSourceHelper *source)
: mDataSource(source),
mOffset(0),
mFinalResult(OK),
mBuffer(new ABuffer(0)),
mScanning(true),
mProgramStreamMapValid(false) {
for (size_t i = 0; i < 500; ++i) {
if (feedMore() != OK) {
break;
}
}
// Remove all tracks that were unable to determine their format.
AMediaFormat *meta = AMediaFormat_new();
for (size_t i = mTracks.size(); i > 0;) {
i--;
Track *track = mTracks.valueAt(i);
if (track->getFormat(meta) != AMEDIA_OK) {
mTracks.removeItemsAt(i);
delete track;
}
}
AMediaFormat_delete(meta);
mScanning = false;
}
MPEG2PSExtractor::~MPEG2PSExtractor() {
delete mDataSource;
for (size_t i = mTracks.size(); i > 0;) {
i--;
delete mTracks.valueAt(i);
}
}
size_t MPEG2PSExtractor::countTracks() {
return mTracks.size();
}
MediaTrackHelper *MPEG2PSExtractor::getTrack(size_t index) {
if (index >= mTracks.size()) {
return NULL;
}
return new WrappedTrack(this, mTracks.valueAt(index));
}
media_status_t MPEG2PSExtractor::getTrackMetaData(
AMediaFormat *meta,
size_t index, uint32_t /* flags */) {
if (index >= mTracks.size()) {
return AMEDIA_ERROR_UNKNOWN;
}
return mTracks.valueAt(index)->getFormat(meta);
}
media_status_t MPEG2PSExtractor::getMetaData(AMediaFormat *meta) {
AMediaFormat_setString(meta, AMEDIAFORMAT_KEY_MIME, MEDIA_MIMETYPE_CONTAINER_MPEG2PS);
return AMEDIA_OK;
}
uint32_t MPEG2PSExtractor::flags() const {
return CAN_PAUSE;
}
status_t MPEG2PSExtractor::feedMore() {
Mutex::Autolock autoLock(mLock);
// How much data we're reading at a time
static const size_t kChunkSize = 8192;
for (;;) {
status_t err = dequeueChunk();
if (err == -EAGAIN && mFinalResult == OK) {
memmove(mBuffer->base(), mBuffer->data(), mBuffer->size());
mBuffer->setRange(0, mBuffer->size());
if (mBuffer->size() + kChunkSize > mBuffer->capacity()) {
size_t newCapacity = mBuffer->capacity() + kChunkSize;
sp<ABuffer> newBuffer = new ABuffer(newCapacity);
memcpy(newBuffer->data(), mBuffer->data(), mBuffer->size());
newBuffer->setRange(0, mBuffer->size());
mBuffer = newBuffer;
}
ssize_t n = mDataSource->readAt(
mOffset, mBuffer->data() + mBuffer->size(), kChunkSize);
if (n < (ssize_t)kChunkSize) {
mFinalResult = (n < 0) ? (status_t)n : ERROR_END_OF_STREAM;
return mFinalResult;
}
mBuffer->setRange(mBuffer->offset(), mBuffer->size() + n);
mOffset += n;
} else if (err != OK) {
mFinalResult = err;
return err;
} else {
return OK;
}
}
}
status_t MPEG2PSExtractor::dequeueChunk() {
if (mBuffer->size() < 4) {
return -EAGAIN;
}
if (memcmp("\x00\x00\x01", mBuffer->data(), 3)) {
return ERROR_MALFORMED;
}
unsigned chunkType = mBuffer->data()[3];
ssize_t res;
switch (chunkType) {
case 0xba:
{
res = dequeuePack();
break;
}
case 0xbb:
{
res = dequeueSystemHeader();
break;
}
default:
{
res = dequeuePES();
break;
}
}
if (res > 0) {
if (mBuffer->size() < (size_t)res) {
return -EAGAIN;
}
mBuffer->setRange(mBuffer->offset() + res, mBuffer->size() - res);
res = OK;
}
return res;
}
ssize_t MPEG2PSExtractor::dequeuePack() {
// 32 + 2 + 3 + 1 + 15 + 1 + 15+ 1 + 9 + 1 + 22 + 1 + 1 | +5
if (mBuffer->size() < 14) {
return -EAGAIN;
}
unsigned pack_stuffing_length = mBuffer->data()[13] & 7;
return pack_stuffing_length + 14;
}
ssize_t MPEG2PSExtractor::dequeueSystemHeader() {
if (mBuffer->size() < 6) {
return -EAGAIN;
}
unsigned header_length = U16_AT(mBuffer->data() + 4);
return header_length + 6;
}
ssize_t MPEG2PSExtractor::dequeuePES() {
if (mBuffer->size() < 6) {
return -EAGAIN;
}
unsigned PES_packet_length = U16_AT(mBuffer->data() + 4);
if (PES_packet_length == 0u) {
ALOGE("PES_packet_length is 0");
return -EAGAIN;
}
size_t n = PES_packet_length + 6;
if (mBuffer->size() < n) {
return -EAGAIN;
}
ABitReader br(mBuffer->data(), n);
unsigned packet_startcode_prefix = br.getBits(24);
ALOGV("packet_startcode_prefix = 0x%08x", packet_startcode_prefix);
if (packet_startcode_prefix != 1) {
ALOGV("Supposedly payload_unit_start=1 unit does not start "
"with startcode.");
return ERROR_MALFORMED;
}
if (packet_startcode_prefix != 0x000001u) {
ALOGE("Wrong PES prefix");
return ERROR_MALFORMED;
}
unsigned stream_id = br.getBits(8);
ALOGV("stream_id = 0x%02x", stream_id);
/* unsigned PES_packet_length = */br.getBits(16);
if (stream_id == 0xbc) {
// program_stream_map
if (!mScanning) {
return n;
}
mStreamTypeByESID.clear();
/* unsigned current_next_indicator = */br.getBits(1);
/* unsigned reserved = */br.getBits(2);
/* unsigned program_stream_map_version = */br.getBits(5);
/* unsigned reserved = */br.getBits(7);
/* unsigned marker_bit = */br.getBits(1);
unsigned program_stream_info_length = br.getBits(16);
size_t offset = 0;
while (offset < program_stream_info_length) {
if (offset + 2 > program_stream_info_length) {
return ERROR_MALFORMED;
}
unsigned descriptor_tag = br.getBits(8);
unsigned descriptor_length = br.getBits(8);
ALOGI("found descriptor tag 0x%02x of length %u",
descriptor_tag, descriptor_length);
if (offset + 2 + descriptor_length > program_stream_info_length) {
return ERROR_MALFORMED;
}
br.skipBits(8 * descriptor_length);
offset += 2 + descriptor_length;
}
unsigned elementary_stream_map_length = br.getBits(16);
offset = 0;
while (offset < elementary_stream_map_length) {
if (offset + 4 > elementary_stream_map_length) {
return ERROR_MALFORMED;
}
unsigned stream_type = br.getBits(8);
unsigned elementary_stream_id = br.getBits(8);
ALOGI("elementary stream id 0x%02x has stream type 0x%02x",
elementary_stream_id, stream_type);
mStreamTypeByESID.add(elementary_stream_id, stream_type);
unsigned elementary_stream_info_length = br.getBits(16);
if (offset + 4 + elementary_stream_info_length
> elementary_stream_map_length) {
return ERROR_MALFORMED;
}
offset += 4 + elementary_stream_info_length;
}
/* unsigned CRC32 = */br.getBits(32);
mProgramStreamMapValid = true;
} else if (stream_id != 0xbe // padding_stream
&& stream_id != 0xbf // private_stream_2
&& stream_id != 0xf0 // ECM
&& stream_id != 0xf1 // EMM
&& stream_id != 0xff // program_stream_directory
&& stream_id != 0xf2 // DSMCC
&& stream_id != 0xf8) { // H.222.1 type E
/* unsigned PES_marker_bits = */br.getBits(2); // should be 0x2(hex)
/* unsigned PES_scrambling_control = */br.getBits(2);
/* unsigned PES_priority = */br.getBits(1);
/* unsigned data_alignment_indicator = */br.getBits(1);
/* unsigned copyright = */br.getBits(1);
/* unsigned original_or_copy = */br.getBits(1);
unsigned PTS_DTS_flags = br.getBits(2);
ALOGV("PTS_DTS_flags = %u", PTS_DTS_flags);
unsigned ESCR_flag = br.getBits(1);
ALOGV("ESCR_flag = %u", ESCR_flag);
unsigned ES_rate_flag = br.getBits(1);
ALOGV("ES_rate_flag = %u", ES_rate_flag);
unsigned DSM_trick_mode_flag = br.getBits(1);
ALOGV("DSM_trick_mode_flag = %u", DSM_trick_mode_flag);
unsigned additional_copy_info_flag = br.getBits(1);
ALOGV("additional_copy_info_flag = %u", additional_copy_info_flag);
/* unsigned PES_CRC_flag = */br.getBits(1);
/* PES_extension_flag = */br.getBits(1);
unsigned PES_header_data_length = br.getBits(8);
ALOGV("PES_header_data_length = %u", PES_header_data_length);
unsigned optional_bytes_remaining = PES_header_data_length;
uint64_t PTS = 0, DTS = 0;
if (PTS_DTS_flags == 2 || PTS_DTS_flags == 3) {
if (optional_bytes_remaining < 5u) {
return ERROR_MALFORMED;
}
if (br.getBits(4) != PTS_DTS_flags) {
return ERROR_MALFORMED;
}
PTS = ((uint64_t)br.getBits(3)) << 30;
if (br.getBits(1) != 1u) {
return ERROR_MALFORMED;
}
PTS |= ((uint64_t)br.getBits(15)) << 15;
if (br.getBits(1) != 1u) {
return ERROR_MALFORMED;
}
PTS |= br.getBits(15);
if (br.getBits(1) != 1u) {
return ERROR_MALFORMED;
}
ALOGV("PTS = %" PRIu64, PTS);
// ALOGI("PTS = %.2f secs", PTS / 90000.0f);
optional_bytes_remaining -= 5;
if (PTS_DTS_flags == 3) {
if (optional_bytes_remaining < 5u) {
return ERROR_MALFORMED;
}
if (br.getBits(4) != 1u) {
return ERROR_MALFORMED;
}
DTS = ((uint64_t)br.getBits(3)) << 30;
if (br.getBits(1) != 1u) {
return ERROR_MALFORMED;
}
DTS |= ((uint64_t)br.getBits(15)) << 15;
if (br.getBits(1) != 1u) {
return ERROR_MALFORMED;
}
DTS |= br.getBits(15);
if (br.getBits(1) != 1u) {
return ERROR_MALFORMED;
}
ALOGV("DTS = %" PRIu64, DTS);
optional_bytes_remaining -= 5;
}
}
if (ESCR_flag) {
if (optional_bytes_remaining < 6u) {
return ERROR_MALFORMED;
}
br.getBits(2);
uint64_t ESCR = ((uint64_t)br.getBits(3)) << 30;
if (br.getBits(1) != 1u) {
return ERROR_MALFORMED;
}
ESCR |= ((uint64_t)br.getBits(15)) << 15;
if (br.getBits(1) != 1u) {
return ERROR_MALFORMED;
}
ESCR |= br.getBits(15);
if (br.getBits(1) != 1u) {
return ERROR_MALFORMED;
}
ALOGV("ESCR = %" PRIu64, ESCR);
/* unsigned ESCR_extension = */br.getBits(9);
if (br.getBits(1) != 1u) {
return ERROR_MALFORMED;
}
optional_bytes_remaining -= 6;
}
if (ES_rate_flag) {
if (optional_bytes_remaining < 3u) {
return ERROR_MALFORMED;
}
if (br.getBits(1) != 1u) {
return ERROR_MALFORMED;
}
/* unsigned ES_rate = */br.getBits(22);
if (br.getBits(1) != 1u) {
return ERROR_MALFORMED;
}
optional_bytes_remaining -= 3;
}
if (br.numBitsLeft() < optional_bytes_remaining * 8) {
return ERROR_MALFORMED;
}
br.skipBits(optional_bytes_remaining * 8);
// ES data follows.
if (PES_packet_length < PES_header_data_length + 3) {
return ERROR_MALFORMED;
}
unsigned dataLength =
PES_packet_length - 3 - PES_header_data_length;
if (br.numBitsLeft() < dataLength * 8) {
ALOGE("PES packet does not carry enough data to contain "
"payload. (numBitsLeft = %zu, required = %u)",
br.numBitsLeft(), dataLength * 8);
return ERROR_MALFORMED;
}
if (br.numBitsLeft() < dataLength * 8) {
return ERROR_MALFORMED;
}
ssize_t index = mTracks.indexOfKey(stream_id);
if (index < 0 && mScanning) {
unsigned streamType;
ssize_t streamTypeIndex;
if (mProgramStreamMapValid
&& (streamTypeIndex =
mStreamTypeByESID.indexOfKey(stream_id)) >= 0) {
streamType = mStreamTypeByESID.valueAt(streamTypeIndex);
} else if ((stream_id & ~0x1f) == 0xc0) {
// ISO/IEC 13818-3 or ISO/IEC 11172-3 or ISO/IEC 13818-7
// or ISO/IEC 14496-3 audio
streamType = ATSParser::STREAMTYPE_MPEG2_AUDIO;
} else if ((stream_id & ~0x0f) == 0xe0) {
// ISO/IEC 13818-2 or ISO/IEC 11172-2 or ISO/IEC 14496-2 video
streamType = ATSParser::STREAMTYPE_MPEG2_VIDEO;
} else {
streamType = ATSParser::STREAMTYPE_RESERVED;
}
index = mTracks.add(
stream_id, new Track(this, stream_id, streamType));
}
status_t err = OK;
if (index >= 0) {
err =
mTracks.editValueAt(index)->appendPESData(
PTS_DTS_flags, PTS, DTS, br.data(), dataLength);
}
br.skipBits(dataLength * 8);
if (err != OK) {
return err;
}
} else if (stream_id == 0xbe) { // padding_stream
if (PES_packet_length == 0u) {
return ERROR_MALFORMED;
}
br.skipBits(PES_packet_length * 8);
} else {
if (PES_packet_length == 0u) {
return ERROR_MALFORMED;
}
br.skipBits(PES_packet_length * 8);
}
return n;
}
////////////////////////////////////////////////////////////////////////////////
MPEG2PSExtractor::Track::Track(
MPEG2PSExtractor *extractor, unsigned stream_id, unsigned stream_type)
: mExtractor(extractor),
mStreamID(stream_id),
mStreamType(stream_type),
mQueue(NULL) {
bool supported = true;
ElementaryStreamQueue::Mode mode;
switch (mStreamType) {
case ATSParser::STREAMTYPE_H264:
mode = ElementaryStreamQueue::H264;
break;
case ATSParser::STREAMTYPE_MPEG2_AUDIO_ADTS:
mode = ElementaryStreamQueue::AAC;
break;
case ATSParser::STREAMTYPE_MPEG1_AUDIO:
case ATSParser::STREAMTYPE_MPEG2_AUDIO:
mode = ElementaryStreamQueue::MPEG_AUDIO;
break;
case ATSParser::STREAMTYPE_MPEG1_VIDEO:
case ATSParser::STREAMTYPE_MPEG2_VIDEO:
mode = ElementaryStreamQueue::MPEG_VIDEO;
break;
case ATSParser::STREAMTYPE_MPEG4_VIDEO:
mode = ElementaryStreamQueue::MPEG4_VIDEO;
break;
default:
supported = false;
break;
}
if (supported) {
mQueue = new ElementaryStreamQueue(mode);
} else {
ALOGI("unsupported stream ID 0x%02x", stream_id);
}
}
MPEG2PSExtractor::Track::~Track() {
delete mQueue;
mQueue = NULL;
}
media_status_t MPEG2PSExtractor::Track::start() {
if (mSource == NULL) {
return AMEDIA_ERROR_UNKNOWN;
}
// initialize with one small buffer, but allow growth
mBufferGroup->init(1 /* one buffer */, 256 /* buffer size */, 64 /* max number of buffers */);
if (mSource->start(NULL) == OK) { // AnotherPacketSource::start doesn't use its argument
return AMEDIA_OK;
}
return AMEDIA_ERROR_UNKNOWN;
}
media_status_t MPEG2PSExtractor::Track::stop() {
if (mSource == NULL) {
return AMEDIA_ERROR_UNKNOWN;
}
if (mSource->stop() == OK) {
return AMEDIA_OK;
}
return AMEDIA_ERROR_UNKNOWN;
}
void copyAMessageToAMediaFormat(AMediaFormat *format, sp<AMessage> msg);
media_status_t MPEG2PSExtractor::Track::getFormat(AMediaFormat *meta) {
if (mSource == NULL) {
return AMEDIA_ERROR_UNKNOWN;
}
sp<MetaData> sourceMeta = mSource->getFormat();
sp<AMessage> msg;
convertMetaDataToMessage(sourceMeta, &msg);
copyAMessageToAMediaFormat(meta, msg);
return AMEDIA_OK;
}
media_status_t MPEG2PSExtractor::Track::read(
MediaBufferHelper **buffer, const ReadOptions *options) {
if (mSource == NULL) {
return AMEDIA_ERROR_UNKNOWN;
}
status_t finalResult;
while (!mSource->hasBufferAvailable(&finalResult)) {
if (finalResult != OK) {
return AMEDIA_ERROR_END_OF_STREAM;
}
status_t err = mExtractor->feedMore();
if (err != OK) {
mSource->signalEOS(err);
}
}
MediaBufferBase *mbuf;
mSource->read(&mbuf, (MediaTrack::ReadOptions*) options);
size_t length = mbuf->range_length();
MediaBufferHelper *outbuf;
mBufferGroup->acquire_buffer(&outbuf, false, length);
memcpy(outbuf->data(), mbuf->data(), length);
outbuf->set_range(0, length);
*buffer = outbuf;
MetaDataBase &inMeta = mbuf->meta_data();
AMediaFormat *outMeta = outbuf->meta_data();
int64_t val64;
if (inMeta.findInt64(kKeyTime, &val64)) {
AMediaFormat_setInt64(outMeta, AMEDIAFORMAT_KEY_TIME_US, val64);
}
int32_t val32;
if (inMeta.findInt32(kKeyIsSyncFrame, &val32)) {
AMediaFormat_setInt32(outMeta, AMEDIAFORMAT_KEY_IS_SYNC_FRAME, val32);
}
if (inMeta.findInt32(kKeyCryptoMode, &val32)) {
AMediaFormat_setInt32(outMeta, AMEDIAFORMAT_KEY_CRYPTO_MODE, val32);
}
uint32_t bufType;
const void *bufData;
size_t bufSize;
if (inMeta.findData(kKeyCryptoIV, &bufType, &bufData, &bufSize)) {
AMediaFormat_setBuffer(outMeta, AMEDIAFORMAT_KEY_CRYPTO_IV, bufData, bufSize);
}
if (inMeta.findData(kKeyCryptoKey, &bufType, &bufData, &bufSize)) {
AMediaFormat_setBuffer(outMeta, AMEDIAFORMAT_KEY_CRYPTO_KEY, bufData, bufSize);
}
if (inMeta.findData(kKeyPlainSizes, &bufType, &bufData, &bufSize)) {
AMediaFormat_setBuffer(outMeta, AMEDIAFORMAT_KEY_CRYPTO_PLAIN_SIZES, bufData, bufSize);
}
if (inMeta.findData(kKeyEncryptedSizes, &bufType, &bufData, &bufSize)) {
AMediaFormat_setBuffer(outMeta, AMEDIAFORMAT_KEY_CRYPTO_ENCRYPTED_SIZES, bufData, bufSize);
}
if (inMeta.findData(kKeySEI, &bufType, &bufData, &bufSize)) {
AMediaFormat_setBuffer(outMeta, AMEDIAFORMAT_KEY_SEI, bufData, bufSize);
}
if (inMeta.findData(kKeyAudioPresentationInfo, &bufType, &bufData, &bufSize)) {
AMediaFormat_setBuffer(outMeta, AMEDIAFORMAT_KEY_AUDIO_PRESENTATION_INFO, bufData, bufSize);
}
mbuf->release();
return AMEDIA_OK;
}
status_t MPEG2PSExtractor::Track::appendPESData(
unsigned PTS_DTS_flags,
uint64_t PTS, uint64_t /* DTS */,
const uint8_t *data, size_t size) {
if (mQueue == NULL) {
return OK;
}
int64_t timeUs;
if (PTS_DTS_flags == 2 || PTS_DTS_flags == 3) {
timeUs = (PTS * 100) / 9;
} else {
timeUs = 0;
}
status_t err = mQueue->appendData(data, size, timeUs);
if (err != OK) {
return err;
}
sp<ABuffer> accessUnit;
while ((accessUnit = mQueue->dequeueAccessUnit()) != NULL) {
if (mSource == NULL) {
sp<MetaData> meta = mQueue->getFormat();
if (meta != NULL) {
ALOGV("Stream ID 0x%02x now has data.", mStreamID);
mSource = new AnotherPacketSource(meta);
mSource->queueAccessUnit(accessUnit);
}
} else if (mQueue->getFormat() != NULL) {
mSource->queueAccessUnit(accessUnit);
}
}
return OK;
}
////////////////////////////////////////////////////////////////////////////////
MPEG2PSExtractor::WrappedTrack::WrappedTrack(
MPEG2PSExtractor *extractor, Track *track)
: mExtractor(extractor),
mTrack(track) {
}
MPEG2PSExtractor::WrappedTrack::~WrappedTrack() {
}
media_status_t MPEG2PSExtractor::WrappedTrack::start() {
delete mTrack->mBufferGroup;
mTrack->mBufferGroup = mBufferGroup;
mBufferGroup = nullptr;
return mTrack->start();
}
media_status_t MPEG2PSExtractor::WrappedTrack::stop() {
return mTrack->stop();
}
media_status_t MPEG2PSExtractor::WrappedTrack::getFormat(AMediaFormat *meta) {
return mTrack->getFormat(meta);
}
media_status_t MPEG2PSExtractor::WrappedTrack::read(
MediaBufferHelper **buffer, const ReadOptions *options) {
return mTrack->read(buffer, options);
}
////////////////////////////////////////////////////////////////////////////////
bool SniffMPEG2PS(
DataSourceHelper *source, float *confidence) {
uint8_t header[5];
if (source->readAt(0, header, sizeof(header)) < (ssize_t)sizeof(header)) {
return false;
}
if (memcmp("\x00\x00\x01\xba", header, 4) || (header[4] >> 6) != 1) {
return false;
}
*confidence = 0.25f; // Slightly larger than .mp3 extractor's confidence
return true;
}
} // namespace android
Reference in New Issue View Git Blame Copy Permalink