You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2556 lines
83 KiB
2556 lines
83 KiB
/*
|
|
* Copyright (C) 2010 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 "ATSParser"
|
|
#include <utils/Log.h>
|
|
#include "ATSParser.h"
|
|
#include "AnotherPacketSource.h"
|
|
#include "CasManager.h"
|
|
#include "ESQueue.h"
|
|
|
|
#include <android/hardware/cas/native/1.0/IDescrambler.h>
|
|
#include <android/hidl/allocator/1.0/IAllocator.h>
|
|
#include <android/hidl/memory/1.0/IMemory.h>
|
|
#include <cutils/native_handle.h>
|
|
#include <hidlmemory/mapping.h>
|
|
#include <media/cas/DescramblerAPI.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/MediaKeys.h>
|
|
#include <media/stagefright/foundation/avc_utils.h>
|
|
#include <media/stagefright/foundation/hexdump.h>
|
|
#include <media/stagefright/MediaDefs.h>
|
|
#include <media/stagefright/MediaErrors.h>
|
|
#include <media/stagefright/MetaData.h>
|
|
#include <media/IStreamSource.h>
|
|
#include <utils/KeyedVector.h>
|
|
#include <utils/Vector.h>
|
|
|
|
#include <inttypes.h>
|
|
|
|
namespace android {
|
|
using hardware::hidl_string;
|
|
using hardware::hidl_vec;
|
|
using hardware::hidl_memory;
|
|
using namespace hardware::cas::V1_0;
|
|
using namespace hardware::cas::native::V1_0;
|
|
typedef hidl::allocator::V1_0::IAllocator TAllocator;
|
|
typedef hidl::memory::V1_0::IMemory TMemory;
|
|
|
|
// I want the expression "y" evaluated even if verbose logging is off.
|
|
#define MY_LOGV(x, y) \
|
|
do { unsigned tmp = y; ALOGV(x, tmp); } while (0)
|
|
|
|
static const size_t kTSPacketSize = 188;
|
|
|
|
struct ATSParser::Program : public RefBase {
|
|
Program(ATSParser *parser, unsigned programNumber, unsigned programMapPID,
|
|
int64_t lastRecoveredPTS);
|
|
|
|
bool parsePSISection(
|
|
unsigned pid, ABitReader *br, status_t *err);
|
|
|
|
// Pass to appropriate stream according to pid, and set event if it's a PES
|
|
// with a sync frame.
|
|
// Note that the method itself does not touch event.
|
|
bool parsePID(
|
|
unsigned pid, unsigned continuity_counter,
|
|
unsigned payload_unit_start_indicator,
|
|
unsigned transport_scrambling_control,
|
|
unsigned random_access_indicator,
|
|
ABitReader *br, status_t *err, SyncEvent *event);
|
|
|
|
void signalDiscontinuity(
|
|
DiscontinuityType type, const sp<AMessage> &extra);
|
|
|
|
void signalEOS(status_t finalResult);
|
|
|
|
sp<AnotherPacketSource> getSource(SourceType type);
|
|
bool hasSource(SourceType type) const;
|
|
|
|
int64_t convertPTSToTimestamp(uint64_t PTS);
|
|
|
|
bool PTSTimeDeltaEstablished() const {
|
|
return mFirstPTSValid;
|
|
}
|
|
|
|
unsigned number() const { return mProgramNumber; }
|
|
|
|
void updateProgramMapPID(unsigned programMapPID) {
|
|
mProgramMapPID = programMapPID;
|
|
}
|
|
|
|
unsigned programMapPID() const {
|
|
return mProgramMapPID;
|
|
}
|
|
|
|
uint32_t parserFlags() const {
|
|
return mParser->mFlags;
|
|
}
|
|
|
|
sp<CasManager> casManager() const {
|
|
return mParser->mCasManager;
|
|
}
|
|
|
|
uint64_t firstPTS() const {
|
|
return mFirstPTS;
|
|
}
|
|
|
|
void updateCasSessions();
|
|
|
|
void signalNewSampleAesKey(const sp<AMessage> &keyItem);
|
|
|
|
private:
|
|
|
|
ATSParser *mParser;
|
|
unsigned mProgramNumber;
|
|
unsigned mProgramMapPID;
|
|
uint32_t mPMTVersion;
|
|
uint32_t mPMT_CRC;
|
|
KeyedVector<unsigned, sp<Stream> > mStreams;
|
|
bool mFirstPTSValid;
|
|
uint64_t mFirstPTS;
|
|
int64_t mLastRecoveredPTS;
|
|
sp<AMessage> mSampleAesKeyItem;
|
|
|
|
status_t parseProgramMap(ABitReader *br);
|
|
int64_t recoverPTS(uint64_t PTS_33bit);
|
|
bool findCADescriptor(
|
|
ABitReader *br, unsigned infoLength, CADescriptor *caDescriptor);
|
|
bool switchPIDs(const Vector<StreamInfo> &infos);
|
|
|
|
DISALLOW_EVIL_CONSTRUCTORS(Program);
|
|
};
|
|
|
|
struct ATSParser::Stream : public RefBase {
|
|
Stream(Program *program, unsigned PCR_PID, const StreamInfo &info);
|
|
|
|
unsigned type() const { return mStreamType; }
|
|
unsigned typeExt() const { return mStreamTypeExt; }
|
|
unsigned pid() const { return mElementaryPID; }
|
|
void setPID(unsigned pid) { mElementaryPID = pid; }
|
|
void setAudioPresentations(AudioPresentationCollection audioPresentations) {
|
|
mAudioPresentations = audioPresentations;
|
|
}
|
|
|
|
void setCasInfo(
|
|
int32_t systemId,
|
|
const sp<IDescrambler> &descrambler,
|
|
const std::vector<uint8_t> &sessionId);
|
|
|
|
// Parse the payload and set event when PES with a sync frame is detected.
|
|
// This method knows when a PES starts; so record mPesStartOffsets in that
|
|
// case.
|
|
status_t parse(
|
|
unsigned continuity_counter,
|
|
unsigned payload_unit_start_indicator,
|
|
unsigned transport_scrambling_control,
|
|
unsigned random_access_indicator,
|
|
ABitReader *br,
|
|
SyncEvent *event);
|
|
|
|
void signalDiscontinuity(
|
|
DiscontinuityType type, const sp<AMessage> &extra);
|
|
|
|
void signalEOS(status_t finalResult);
|
|
|
|
SourceType getSourceType();
|
|
sp<AnotherPacketSource> getSource(SourceType type);
|
|
|
|
bool isAudio() const;
|
|
bool isVideo() const;
|
|
bool isMeta() const;
|
|
|
|
void signalNewSampleAesKey(const sp<AMessage> &keyItem);
|
|
|
|
protected:
|
|
virtual ~Stream();
|
|
|
|
private:
|
|
struct SubSampleInfo {
|
|
size_t subSampleSize;
|
|
unsigned transport_scrambling_mode;
|
|
unsigned random_access_indicator;
|
|
};
|
|
Program *mProgram;
|
|
unsigned mElementaryPID;
|
|
unsigned mStreamType;
|
|
unsigned mStreamTypeExt;
|
|
unsigned mPCR_PID;
|
|
int32_t mExpectedContinuityCounter;
|
|
|
|
sp<ABuffer> mBuffer;
|
|
sp<AnotherPacketSource> mSource;
|
|
bool mPayloadStarted;
|
|
bool mEOSReached;
|
|
|
|
uint64_t mPrevPTS;
|
|
List<off64_t> mPesStartOffsets;
|
|
|
|
ElementaryStreamQueue *mQueue;
|
|
|
|
bool mScrambled;
|
|
bool mSampleEncrypted;
|
|
sp<AMessage> mSampleAesKeyItem;
|
|
sp<TMemory> mHidlMemory;
|
|
sp<TAllocator> mHidlAllocator;
|
|
hardware::cas::native::V1_0::SharedBuffer mDescramblerSrcBuffer;
|
|
sp<ABuffer> mDescrambledBuffer;
|
|
List<SubSampleInfo> mSubSamples;
|
|
sp<IDescrambler> mDescrambler;
|
|
AudioPresentationCollection mAudioPresentations;
|
|
|
|
// Send audio presentations along with access units.
|
|
void addAudioPresentations(const sp<ABuffer> &buffer);
|
|
|
|
// Flush accumulated payload if necessary --- i.e. at EOS or at the start of
|
|
// another payload. event is set if the flushed payload is PES with a sync
|
|
// frame.
|
|
status_t flush(SyncEvent *event);
|
|
|
|
// Flush accumulated payload for scrambled streams if necessary --- i.e. at
|
|
// EOS or at the start of another payload. event is set if the flushed
|
|
// payload is PES with a sync frame.
|
|
status_t flushScrambled(SyncEvent *event);
|
|
|
|
// Check if a PES packet is scrambled at PES level.
|
|
uint32_t getPesScramblingControl(ABitReader *br, int32_t *pesOffset);
|
|
|
|
// Strip and parse PES headers and pass remaining payload into onPayload
|
|
// with parsed metadata. event is set if the PES contains a sync frame.
|
|
status_t parsePES(ABitReader *br, SyncEvent *event);
|
|
|
|
// Feed the payload into mQueue and if a packet is identified, queue it
|
|
// into mSource. If the packet is a sync frame. set event with start offset
|
|
// and timestamp of the packet.
|
|
void onPayloadData(
|
|
unsigned PTS_DTS_flags, uint64_t PTS, uint64_t DTS,
|
|
unsigned PES_scrambling_control,
|
|
const uint8_t *data, size_t size,
|
|
int32_t payloadOffset, SyncEvent *event);
|
|
|
|
// Ensure internal buffers can hold specified size, and will re-allocate
|
|
// as needed.
|
|
bool ensureBufferCapacity(size_t size);
|
|
|
|
DISALLOW_EVIL_CONSTRUCTORS(Stream);
|
|
};
|
|
|
|
struct ATSParser::PSISection : public RefBase {
|
|
PSISection();
|
|
|
|
status_t append(const void *data, size_t size);
|
|
void setSkipBytes(uint8_t skip);
|
|
void clear();
|
|
|
|
bool isComplete() const;
|
|
bool isEmpty() const;
|
|
bool isCRCOkay() const;
|
|
|
|
const uint8_t *data() const;
|
|
size_t size() const;
|
|
|
|
protected:
|
|
virtual ~PSISection();
|
|
|
|
private:
|
|
sp<ABuffer> mBuffer;
|
|
uint8_t mSkipBytes;
|
|
static uint32_t CRC_TABLE[];
|
|
|
|
DISALLOW_EVIL_CONSTRUCTORS(PSISection);
|
|
};
|
|
|
|
ATSParser::SyncEvent::SyncEvent(off64_t offset)
|
|
: mHasReturnedData(false), mOffset(offset), mTimeUs(0) {}
|
|
|
|
void ATSParser::SyncEvent::init(off64_t offset, const sp<AnotherPacketSource> &source,
|
|
int64_t timeUs, SourceType type) {
|
|
mHasReturnedData = true;
|
|
mOffset = offset;
|
|
mMediaSource = source;
|
|
mTimeUs = timeUs;
|
|
mType = type;
|
|
}
|
|
|
|
void ATSParser::SyncEvent::reset() {
|
|
mHasReturnedData = false;
|
|
}
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
ATSParser::Program::Program(
|
|
ATSParser *parser, unsigned programNumber, unsigned programMapPID,
|
|
int64_t lastRecoveredPTS)
|
|
: mParser(parser),
|
|
mProgramNumber(programNumber),
|
|
mProgramMapPID(programMapPID),
|
|
mPMTVersion(0xffffffff),
|
|
mPMT_CRC(0xffffffff),
|
|
mFirstPTSValid(false),
|
|
mFirstPTS(0),
|
|
mLastRecoveredPTS(lastRecoveredPTS) {
|
|
ALOGV("new program number %u", programNumber);
|
|
}
|
|
|
|
bool ATSParser::Program::parsePSISection(
|
|
unsigned pid, ABitReader *br, status_t *err) {
|
|
*err = OK;
|
|
|
|
if (pid != mProgramMapPID) {
|
|
return false;
|
|
}
|
|
|
|
*err = parseProgramMap(br);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool ATSParser::Program::parsePID(
|
|
unsigned pid, unsigned continuity_counter,
|
|
unsigned payload_unit_start_indicator,
|
|
unsigned transport_scrambling_control,
|
|
unsigned random_access_indicator,
|
|
ABitReader *br, status_t *err, SyncEvent *event) {
|
|
*err = OK;
|
|
|
|
ssize_t index = mStreams.indexOfKey(pid);
|
|
if (index < 0) {
|
|
return false;
|
|
}
|
|
|
|
*err = mStreams.editValueAt(index)->parse(
|
|
continuity_counter,
|
|
payload_unit_start_indicator,
|
|
transport_scrambling_control,
|
|
random_access_indicator,
|
|
br, event);
|
|
|
|
return true;
|
|
}
|
|
|
|
void ATSParser::Program::signalDiscontinuity(
|
|
DiscontinuityType type, const sp<AMessage> &extra) {
|
|
int64_t mediaTimeUs;
|
|
if ((type & DISCONTINUITY_TIME)
|
|
&& extra != NULL
|
|
&& extra->findInt64(
|
|
kATSParserKeyMediaTimeUs, &mediaTimeUs)) {
|
|
mFirstPTSValid = false;
|
|
}
|
|
|
|
for (size_t i = 0; i < mStreams.size(); ++i) {
|
|
mStreams.editValueAt(i)->signalDiscontinuity(type, extra);
|
|
}
|
|
}
|
|
|
|
void ATSParser::Program::signalEOS(status_t finalResult) {
|
|
for (size_t i = 0; i < mStreams.size(); ++i) {
|
|
mStreams.editValueAt(i)->signalEOS(finalResult);
|
|
}
|
|
}
|
|
|
|
bool ATSParser::Program::switchPIDs(const Vector<StreamInfo> &infos) {
|
|
bool success = false;
|
|
|
|
if (mStreams.size() == infos.size()) {
|
|
// build type->PIDs map for old and new mapping
|
|
size_t i;
|
|
KeyedVector<int32_t, Vector<int32_t> > oldType2PIDs, newType2PIDs;
|
|
for (i = 0; i < mStreams.size(); ++i) {
|
|
ssize_t index = oldType2PIDs.indexOfKey(mStreams[i]->type());
|
|
if (index < 0) {
|
|
oldType2PIDs.add(mStreams[i]->type(), Vector<int32_t>());
|
|
}
|
|
oldType2PIDs.editValueFor(mStreams[i]->type()).push_back(mStreams[i]->pid());
|
|
}
|
|
for (i = 0; i < infos.size(); ++i) {
|
|
ssize_t index = newType2PIDs.indexOfKey(infos[i].mType);
|
|
if (index < 0) {
|
|
newType2PIDs.add(infos[i].mType, Vector<int32_t>());
|
|
}
|
|
newType2PIDs.editValueFor(infos[i].mType).push_back(infos[i].mPID);
|
|
}
|
|
|
|
// we can recover if the number of streams for each type hasn't changed
|
|
if (oldType2PIDs.size() == newType2PIDs.size()) {
|
|
success = true;
|
|
for (i = 0; i < oldType2PIDs.size(); ++i) {
|
|
// KeyedVector is sorted, we just compare key and size of each index
|
|
if (oldType2PIDs.keyAt(i) != newType2PIDs.keyAt(i)
|
|
|| oldType2PIDs[i].size() != newType2PIDs[i].size()) {
|
|
success = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (success) {
|
|
// save current streams to temp
|
|
KeyedVector<int32_t, sp<Stream> > temp;
|
|
for (i = 0; i < mStreams.size(); ++i) {
|
|
temp.add(mStreams.keyAt(i), mStreams.editValueAt(i));
|
|
}
|
|
|
|
mStreams.clear();
|
|
for (i = 0; i < temp.size(); ++i) {
|
|
// The two checks below shouldn't happen,
|
|
// we already checked above the stream count matches
|
|
ssize_t index = newType2PIDs.indexOfKey(temp[i]->type());
|
|
if (index < 0) {
|
|
return false;
|
|
}
|
|
Vector<int32_t> &newPIDs = newType2PIDs.editValueAt(index);
|
|
if (newPIDs.isEmpty()) {
|
|
return false;
|
|
}
|
|
|
|
// get the next PID for temp[i]->type() in the new PID map
|
|
Vector<int32_t>::iterator it = newPIDs.begin();
|
|
|
|
// change the PID of the stream, and add it back
|
|
temp.editValueAt(i)->setPID(*it);
|
|
mStreams.add(temp[i]->pid(), temp.editValueAt(i));
|
|
|
|
// removed the used PID
|
|
newPIDs.erase(it);
|
|
}
|
|
}
|
|
}
|
|
return success;
|
|
}
|
|
|
|
bool ATSParser::Program::findCADescriptor(
|
|
ABitReader *br, unsigned infoLength,
|
|
ATSParser::CADescriptor *caDescriptor) {
|
|
bool found = false;
|
|
while (infoLength > 2) {
|
|
unsigned descriptor_tag = br->getBits(8);
|
|
ALOGV(" tag = 0x%02x", descriptor_tag);
|
|
|
|
unsigned descriptor_length = br->getBits(8);
|
|
ALOGV(" len = %u", descriptor_length);
|
|
|
|
infoLength -= 2;
|
|
if (descriptor_length > infoLength) {
|
|
break;
|
|
}
|
|
if (descriptor_tag == DESCRIPTOR_CA && descriptor_length >= 4) {
|
|
found = true;
|
|
caDescriptor->mSystemID = br->getBits(16);
|
|
caDescriptor->mPID = br->getBits(16) & 0x1fff;
|
|
infoLength -= 4;
|
|
caDescriptor->mPrivateData.assign(
|
|
br->data(), br->data() + descriptor_length - 4);
|
|
break;
|
|
} else {
|
|
infoLength -= descriptor_length;
|
|
br->skipBits(descriptor_length * 8);
|
|
}
|
|
}
|
|
br->skipBits(infoLength * 8);
|
|
return found;
|
|
}
|
|
|
|
status_t ATSParser::Program::parseProgramMap(ABitReader *br) {
|
|
unsigned table_id = br->getBits(8);
|
|
ALOGV(" table_id = %u", table_id);
|
|
if (table_id != 0x02u) {
|
|
ALOGE("PMT data error!");
|
|
return ERROR_MALFORMED;
|
|
}
|
|
unsigned section_syntax_indicator = br->getBits(1);
|
|
ALOGV(" section_syntax_indicator = %u", section_syntax_indicator);
|
|
if (section_syntax_indicator != 1u) {
|
|
ALOGE("PMT data error!");
|
|
return ERROR_MALFORMED;
|
|
}
|
|
|
|
br->skipBits(1); // '0'
|
|
MY_LOGV(" reserved = %u", br->getBits(2));
|
|
|
|
unsigned section_length = br->getBits(12);
|
|
ALOGV(" section_length = %u", section_length);
|
|
|
|
MY_LOGV(" program_number = %u", br->getBits(16));
|
|
MY_LOGV(" reserved = %u", br->getBits(2));
|
|
bool audioPresentationsChanged = false;
|
|
unsigned pmtVersion = br->getBits(5);
|
|
if (pmtVersion != mPMTVersion) {
|
|
audioPresentationsChanged = true;
|
|
mPMTVersion = pmtVersion;
|
|
}
|
|
MY_LOGV(" version_number = %u", pmtVersion);
|
|
MY_LOGV(" current_next_indicator = %u", br->getBits(1));
|
|
MY_LOGV(" section_number = %u", br->getBits(8));
|
|
MY_LOGV(" last_section_number = %u", br->getBits(8));
|
|
MY_LOGV(" reserved = %u", br->getBits(3));
|
|
|
|
unsigned PCR_PID = br->getBits(13);
|
|
ALOGV(" PCR_PID = 0x%04x", PCR_PID);
|
|
|
|
MY_LOGV(" reserved = %u", br->getBits(4));
|
|
|
|
unsigned program_info_length = br->getBits(12);
|
|
ALOGV(" program_info_length = %u", program_info_length);
|
|
|
|
// descriptors
|
|
CADescriptor programCA;
|
|
bool hasProgramCA = findCADescriptor(br, program_info_length, &programCA);
|
|
if (hasProgramCA && !mParser->mCasManager->addProgram(
|
|
mProgramNumber, programCA)) {
|
|
return ERROR_MALFORMED;
|
|
}
|
|
|
|
Vector<StreamInfo> infos;
|
|
|
|
// infoBytesRemaining is the number of bytes that make up the
|
|
// variable length section of ES_infos. It does not include the
|
|
// final CRC.
|
|
int32_t infoBytesRemaining = section_length - 9 - program_info_length - 4;
|
|
|
|
while (infoBytesRemaining >= 5) {
|
|
StreamInfo info;
|
|
info.mType = br->getBits(8);
|
|
ALOGV(" stream_type = 0x%02x", info.mType);
|
|
MY_LOGV(" reserved = %u", br->getBits(3));
|
|
|
|
info.mPID = br->getBits(13);
|
|
ALOGV(" elementary_PID = 0x%04x", info.mPID);
|
|
|
|
MY_LOGV(" reserved = %u", br->getBits(4));
|
|
|
|
unsigned ES_info_length = br->getBits(12);
|
|
ALOGV(" ES_info_length = %u", ES_info_length);
|
|
infoBytesRemaining -= 5 + ES_info_length;
|
|
|
|
CADescriptor streamCA;
|
|
info.mTypeExt = EXT_DESCRIPTOR_DVB_RESERVED_MAX;
|
|
|
|
info.mAudioPresentations.clear();
|
|
bool hasStreamCA = false;
|
|
while (ES_info_length > 2 && infoBytesRemaining >= 0) {
|
|
unsigned descriptor_tag = br->getBits(8);
|
|
ALOGV(" tag = 0x%02x", descriptor_tag);
|
|
|
|
unsigned descriptor_length = br->getBits(8);
|
|
ALOGV(" len = %u", descriptor_length);
|
|
|
|
ES_info_length -= 2;
|
|
if (descriptor_length > ES_info_length) {
|
|
return ERROR_MALFORMED;
|
|
}
|
|
if (descriptor_tag == DESCRIPTOR_CA && descriptor_length >= 4) {
|
|
hasStreamCA = true;
|
|
streamCA.mSystemID = br->getBits(16);
|
|
streamCA.mPID = br->getBits(16) & 0x1fff;
|
|
ES_info_length -= descriptor_length;
|
|
descriptor_length -= 4;
|
|
streamCA.mPrivateData.assign(br->data(), br->data() + descriptor_length);
|
|
br->skipBits(descriptor_length * 8);
|
|
} else if (info.mType == STREAMTYPE_PES_PRIVATE_DATA &&
|
|
descriptor_tag == DESCRIPTOR_DVB_EXTENSION && descriptor_length >= 1) {
|
|
unsigned descTagExt = br->getBits(8);
|
|
ALOGV(" tag_ext = 0x%02x", descTagExt);
|
|
ES_info_length -= descriptor_length;
|
|
descriptor_length--;
|
|
// The AC4 descriptor is used in the PSI PMT to identify streams which carry AC4
|
|
// audio.
|
|
if (descTagExt == EXT_DESCRIPTOR_DVB_AC4) {
|
|
info.mTypeExt = EXT_DESCRIPTOR_DVB_AC4;
|
|
br->skipBits(descriptor_length * 8);
|
|
} else if (descTagExt == EXT_DESCRIPTOR_DVB_AUDIO_PRESELECTION &&
|
|
descriptor_length >= 1) {
|
|
// DVB BlueBook A038 Table 110
|
|
unsigned num_preselections = br->getBits(5);
|
|
br->skipBits(3); // reserved
|
|
for (unsigned i = 0; i < num_preselections; ++i) {
|
|
if (br->numBitsLeft() < 16) {
|
|
ALOGE("Not enough data left in bitreader!");
|
|
return ERROR_MALFORMED;
|
|
}
|
|
AudioPresentationV1 ap;
|
|
ap.mPresentationId = br->getBits(5); // preselection_id
|
|
|
|
// audio_rendering_indication
|
|
ap.mMasteringIndication = static_cast<MasteringIndication>(br->getBits(3));
|
|
ap.mAudioDescriptionAvailable = (br->getBits(1) == 1);
|
|
ap.mSpokenSubtitlesAvailable = (br->getBits(1) == 1);
|
|
ap.mDialogueEnhancementAvailable = (br->getBits(1) == 1);
|
|
|
|
bool interactivity_enabled = (br->getBits(1) == 1);
|
|
MY_LOGV(" interactivity_enabled = %d", interactivity_enabled);
|
|
|
|
bool language_code_present = (br->getBits(1) == 1);
|
|
bool text_label_present = (br->getBits(1) == 1);
|
|
|
|
bool multi_stream_info_present = (br->getBits(1) == 1);
|
|
bool future_extension = (br->getBits(1) == 1);
|
|
if (language_code_present) {
|
|
if (br->numBitsLeft() < 24) {
|
|
ALOGE("Not enough data left in bitreader!");
|
|
return ERROR_MALFORMED;
|
|
}
|
|
char language[4];
|
|
language[0] = br->getBits(8);
|
|
language[1] = br->getBits(8);
|
|
language[2] = br->getBits(8);
|
|
language[3] = 0;
|
|
ap.mLanguage = String8(language);
|
|
}
|
|
|
|
// This maps the presentation id to the message id in the
|
|
// EXT_DESCRIPTOR_DVB_MESSAGE so that we can get the presentation label.
|
|
if (text_label_present) {
|
|
if (br->numBitsLeft() < 8) {
|
|
ALOGE("Not enough data left in bitreader!");
|
|
return ERROR_MALFORMED;
|
|
}
|
|
unsigned message_id = br->getBits(8);
|
|
MY_LOGV(" message_id = %u", message_id);
|
|
}
|
|
|
|
if (multi_stream_info_present) {
|
|
if (br->numBitsLeft() < 8) {
|
|
ALOGE("Not enough data left in bitreader!");
|
|
return ERROR_MALFORMED;
|
|
}
|
|
unsigned num_aux_components = br->getBits(3);
|
|
br->skipBits(5); // reserved
|
|
if (br->numBitsLeft() < (num_aux_components * 8)) {
|
|
ALOGE("Not enough data left in bitreader!");
|
|
return ERROR_MALFORMED;
|
|
}
|
|
br->skipBits(num_aux_components * 8); // component_tag
|
|
}
|
|
if (future_extension) {
|
|
if (br->numBitsLeft() < 8) {
|
|
return ERROR_MALFORMED;
|
|
}
|
|
br->skipBits(3); // reserved
|
|
unsigned future_extension_length = br->getBits(5);
|
|
if (br->numBitsLeft() < (future_extension_length * 8)) {
|
|
ALOGE("Not enough data left in bitreader!");
|
|
return ERROR_MALFORMED;
|
|
}
|
|
br->skipBits(future_extension_length * 8); // future_extension_byte
|
|
}
|
|
info.mAudioPresentations.push_back(std::move(ap));
|
|
}
|
|
} else {
|
|
br->skipBits(descriptor_length * 8);
|
|
}
|
|
} else {
|
|
ES_info_length -= descriptor_length;
|
|
br->skipBits(descriptor_length * 8);
|
|
}
|
|
}
|
|
if (hasStreamCA && !mParser->mCasManager->addStream(
|
|
mProgramNumber, info.mPID, streamCA)) {
|
|
return ERROR_MALFORMED;
|
|
}
|
|
if (hasProgramCA) {
|
|
info.mCADescriptor = programCA;
|
|
} else if (hasStreamCA) {
|
|
info.mCADescriptor = streamCA;
|
|
}
|
|
|
|
infos.push(info);
|
|
}
|
|
|
|
if (infoBytesRemaining != 0) {
|
|
ALOGW("Section data remains unconsumed");
|
|
}
|
|
unsigned crc = br->getBits(32);
|
|
if (crc != mPMT_CRC) {
|
|
audioPresentationsChanged = true;
|
|
mPMT_CRC = crc;
|
|
}
|
|
MY_LOGV(" CRC = 0x%08x", crc);
|
|
|
|
bool PIDsChanged = false;
|
|
for (size_t i = 0; i < infos.size(); ++i) {
|
|
StreamInfo &info = infos.editItemAt(i);
|
|
|
|
ssize_t index = mStreams.indexOfKey(info.mPID);
|
|
|
|
if (index >= 0 && mStreams.editValueAt(index)->type() != info.mType) {
|
|
ALOGI("uh oh. stream PIDs have changed.");
|
|
PIDsChanged = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (PIDsChanged) {
|
|
#if 0
|
|
ALOGI("before:");
|
|
for (size_t i = 0; i < mStreams.size(); ++i) {
|
|
sp<Stream> stream = mStreams.editValueAt(i);
|
|
|
|
ALOGI("PID 0x%08x => type 0x%02x", stream->pid(), stream->type());
|
|
}
|
|
|
|
ALOGI("after:");
|
|
for (size_t i = 0; i < infos.size(); ++i) {
|
|
StreamInfo &info = infos.editItemAt(i);
|
|
|
|
ALOGI("PID 0x%08x => type 0x%02x", info.mPID, info.mType);
|
|
}
|
|
#endif
|
|
|
|
// we can recover if number of streams for each type remain the same
|
|
bool success = switchPIDs(infos);
|
|
|
|
if (!success) {
|
|
ALOGI("Stream PIDs changed and we cannot recover.");
|
|
return ERROR_MALFORMED;
|
|
}
|
|
}
|
|
|
|
bool isAddingScrambledStream = false;
|
|
for (size_t i = 0; i < infos.size(); ++i) {
|
|
StreamInfo &info = infos.editItemAt(i);
|
|
|
|
if (mParser->mCasManager->isCAPid(info.mPID)) {
|
|
// skip CA streams (EMM/ECM)
|
|
continue;
|
|
}
|
|
ssize_t index = mStreams.indexOfKey(info.mPID);
|
|
|
|
if (index < 0) {
|
|
sp<Stream> stream = new Stream(this, PCR_PID, info);
|
|
|
|
if (mSampleAesKeyItem != NULL) {
|
|
stream->signalNewSampleAesKey(mSampleAesKeyItem);
|
|
}
|
|
|
|
isAddingScrambledStream |= info.mCADescriptor.mSystemID >= 0;
|
|
mStreams.add(info.mPID, stream);
|
|
}
|
|
else if (index >= 0 && mStreams.editValueAt(index)->isAudio()
|
|
&& audioPresentationsChanged) {
|
|
mStreams.editValueAt(index)->setAudioPresentations(info.mAudioPresentations);
|
|
}
|
|
}
|
|
|
|
if (isAddingScrambledStream) {
|
|
ALOGI("Receiving scrambled streams without descrambler!");
|
|
return ERROR_DRM_DECRYPT_UNIT_NOT_INITIALIZED;
|
|
}
|
|
return OK;
|
|
}
|
|
|
|
int64_t ATSParser::Program::recoverPTS(uint64_t PTS_33bit) {
|
|
// We only have the lower 33-bit of the PTS. It could overflow within a
|
|
// reasonable amount of time. To handle the wrap-around, use fancy math
|
|
// to get an extended PTS that is within [-0xffffffff, 0xffffffff]
|
|
// of the latest recovered PTS.
|
|
if (mLastRecoveredPTS < 0LL) {
|
|
// Use the original 33bit number for 1st frame, the reason is that
|
|
// if 1st frame wraps to negative that's far away from 0, we could
|
|
// never start. Only start wrapping around from 2nd frame.
|
|
mLastRecoveredPTS = static_cast<int64_t>(PTS_33bit);
|
|
} else {
|
|
mLastRecoveredPTS = static_cast<int64_t>(
|
|
((mLastRecoveredPTS - static_cast<int64_t>(PTS_33bit) + 0x100000000LL)
|
|
& 0xfffffffe00000000ull) | PTS_33bit);
|
|
// We start from 0, but recovered PTS could be slightly below 0.
|
|
// Clamp it to 0 as rest of the pipeline doesn't take negative pts.
|
|
// (eg. video is read first and starts at 0, but audio starts at 0xfffffff0)
|
|
if (mLastRecoveredPTS < 0LL) {
|
|
ALOGI("Clamping negative recovered PTS (%" PRId64 ") to 0", mLastRecoveredPTS);
|
|
mLastRecoveredPTS = 0LL;
|
|
}
|
|
}
|
|
|
|
return mLastRecoveredPTS;
|
|
}
|
|
|
|
sp<AnotherPacketSource> ATSParser::Program::getSource(SourceType type) {
|
|
for (size_t i = 0; i < mStreams.size(); ++i) {
|
|
sp<AnotherPacketSource> source = mStreams.editValueAt(i)->getSource(type);
|
|
if (source != NULL) {
|
|
return source;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
bool ATSParser::Program::hasSource(SourceType type) const {
|
|
for (size_t i = 0; i < mStreams.size(); ++i) {
|
|
const sp<Stream> &stream = mStreams.valueAt(i);
|
|
if (type == AUDIO && stream->isAudio()) {
|
|
return true;
|
|
} else if (type == VIDEO && stream->isVideo()) {
|
|
return true;
|
|
} else if (type == META && stream->isMeta()) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
int64_t ATSParser::Program::convertPTSToTimestamp(uint64_t PTS) {
|
|
PTS = recoverPTS(PTS);
|
|
|
|
if (!(mParser->mFlags & TS_TIMESTAMPS_ARE_ABSOLUTE)) {
|
|
if (!mFirstPTSValid) {
|
|
mFirstPTSValid = true;
|
|
mFirstPTS = PTS;
|
|
PTS = 0;
|
|
} else if (PTS < mFirstPTS) {
|
|
PTS = 0;
|
|
} else {
|
|
PTS -= mFirstPTS;
|
|
}
|
|
}
|
|
|
|
int64_t timeUs = (PTS * 100) / 9;
|
|
|
|
if (mParser->mAbsoluteTimeAnchorUs >= 0LL) {
|
|
timeUs += mParser->mAbsoluteTimeAnchorUs;
|
|
}
|
|
|
|
if (mParser->mTimeOffsetValid) {
|
|
timeUs += mParser->mTimeOffsetUs;
|
|
}
|
|
|
|
return timeUs;
|
|
}
|
|
|
|
void ATSParser::Program::updateCasSessions() {
|
|
for (size_t i = 0; i < mStreams.size(); ++i) {
|
|
sp<Stream> &stream = mStreams.editValueAt(i);
|
|
sp<IDescrambler> descrambler;
|
|
std::vector<uint8_t> sessionId;
|
|
int32_t systemId;
|
|
if (mParser->mCasManager->getCasInfo(mProgramNumber, stream->pid(),
|
|
&systemId, &descrambler, &sessionId)) {
|
|
stream->setCasInfo(systemId, descrambler, sessionId);
|
|
}
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
static const size_t kInitialStreamBufferSize = 192 * 1024;
|
|
|
|
ATSParser::Stream::Stream(
|
|
Program *program, unsigned PCR_PID, const StreamInfo &info)
|
|
: mProgram(program),
|
|
mElementaryPID(info.mPID),
|
|
mStreamType(info.mType),
|
|
mStreamTypeExt(info.mTypeExt),
|
|
mPCR_PID(PCR_PID),
|
|
mExpectedContinuityCounter(-1),
|
|
mPayloadStarted(false),
|
|
mEOSReached(false),
|
|
mPrevPTS(0),
|
|
mQueue(NULL),
|
|
mScrambled(info.mCADescriptor.mSystemID >= 0),
|
|
mAudioPresentations(info.mAudioPresentations) {
|
|
mSampleEncrypted =
|
|
mStreamType == STREAMTYPE_H264_ENCRYPTED ||
|
|
mStreamType == STREAMTYPE_AAC_ENCRYPTED ||
|
|
mStreamType == STREAMTYPE_AC3_ENCRYPTED;
|
|
|
|
ALOGV("new stream PID 0x%02x, type 0x%02x, scrambled %d, SampleEncrypted: %d",
|
|
info.mPID, info.mType, mScrambled, mSampleEncrypted);
|
|
|
|
uint32_t flags = 0;
|
|
if (((isVideo() || isAudio()) && mScrambled)) {
|
|
flags = ElementaryStreamQueue::kFlag_ScrambledData;
|
|
} else if (mSampleEncrypted) {
|
|
flags = ElementaryStreamQueue::kFlag_SampleEncryptedData;
|
|
}
|
|
|
|
ElementaryStreamQueue::Mode mode = ElementaryStreamQueue::INVALID;
|
|
|
|
switch (mStreamType) {
|
|
case STREAMTYPE_H264:
|
|
case STREAMTYPE_H264_ENCRYPTED:
|
|
mode = ElementaryStreamQueue::H264;
|
|
flags |= (mProgram->parserFlags() & ALIGNED_VIDEO_DATA) ?
|
|
ElementaryStreamQueue::kFlag_AlignedData : 0;
|
|
break;
|
|
|
|
case STREAMTYPE_MPEG2_AUDIO_ADTS:
|
|
case STREAMTYPE_AAC_ENCRYPTED:
|
|
mode = ElementaryStreamQueue::AAC;
|
|
break;
|
|
|
|
case STREAMTYPE_MPEG1_AUDIO:
|
|
case STREAMTYPE_MPEG2_AUDIO:
|
|
mode = ElementaryStreamQueue::MPEG_AUDIO;
|
|
break;
|
|
|
|
case STREAMTYPE_MPEG1_VIDEO:
|
|
case STREAMTYPE_MPEG2_VIDEO:
|
|
mode = ElementaryStreamQueue::MPEG_VIDEO;
|
|
break;
|
|
|
|
case STREAMTYPE_MPEG4_VIDEO:
|
|
mode = ElementaryStreamQueue::MPEG4_VIDEO;
|
|
break;
|
|
|
|
case STREAMTYPE_LPCM_AC3:
|
|
case STREAMTYPE_AC3:
|
|
case STREAMTYPE_AC3_ENCRYPTED:
|
|
mode = ElementaryStreamQueue::AC3;
|
|
break;
|
|
|
|
case STREAMTYPE_EAC3:
|
|
mode = ElementaryStreamQueue::EAC3;
|
|
break;
|
|
|
|
case STREAMTYPE_PES_PRIVATE_DATA:
|
|
if (mStreamTypeExt == EXT_DESCRIPTOR_DVB_AC4) {
|
|
mode = ElementaryStreamQueue::AC4;
|
|
}
|
|
break;
|
|
|
|
case STREAMTYPE_METADATA:
|
|
mode = ElementaryStreamQueue::METADATA;
|
|
break;
|
|
|
|
default:
|
|
ALOGE("stream PID 0x%02x has invalid stream type 0x%02x",
|
|
info.mPID, info.mType);
|
|
return;
|
|
}
|
|
|
|
mQueue = new ElementaryStreamQueue(mode, flags);
|
|
|
|
if (mQueue != NULL) {
|
|
if (mSampleAesKeyItem != NULL) {
|
|
mQueue->signalNewSampleAesKey(mSampleAesKeyItem);
|
|
}
|
|
|
|
ensureBufferCapacity(kInitialStreamBufferSize);
|
|
|
|
if (mScrambled && (isAudio() || isVideo())) {
|
|
// Set initial format to scrambled
|
|
sp<MetaData> meta = new MetaData();
|
|
meta->setCString(kKeyMIMEType,
|
|
isAudio() ? MEDIA_MIMETYPE_AUDIO_SCRAMBLED
|
|
: MEDIA_MIMETYPE_VIDEO_SCRAMBLED);
|
|
// for MediaExtractor.CasInfo
|
|
const CADescriptor &descriptor = info.mCADescriptor;
|
|
meta->setInt32(kKeyCASystemID, descriptor.mSystemID);
|
|
|
|
meta->setData(kKeyCAPrivateData, 0,
|
|
descriptor.mPrivateData.data(),
|
|
descriptor.mPrivateData.size());
|
|
|
|
mSource = new AnotherPacketSource(meta);
|
|
}
|
|
}
|
|
}
|
|
|
|
ATSParser::Stream::~Stream() {
|
|
delete mQueue;
|
|
mQueue = NULL;
|
|
}
|
|
|
|
bool ATSParser::Stream::ensureBufferCapacity(size_t neededSize) {
|
|
if (mBuffer != NULL && mBuffer->capacity() >= neededSize) {
|
|
return true;
|
|
}
|
|
|
|
ALOGV("ensureBufferCapacity: current size %zu, new size %zu, scrambled %d",
|
|
mBuffer == NULL ? 0 : mBuffer->capacity(), neededSize, mScrambled);
|
|
|
|
sp<ABuffer> newBuffer, newScrambledBuffer;
|
|
sp<TMemory> newMem;
|
|
if (mScrambled) {
|
|
if (mHidlAllocator == nullptr) {
|
|
mHidlAllocator = TAllocator::getService("ashmem");
|
|
if (mHidlAllocator == nullptr) {
|
|
ALOGE("[stream %d] can't get hidl allocator", mElementaryPID);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
hidl_memory hidlMemToken;
|
|
bool success;
|
|
auto transStatus = mHidlAllocator->allocate(
|
|
neededSize,
|
|
[&success, &hidlMemToken](
|
|
bool s,
|
|
hidl_memory const& m) {
|
|
success = s;
|
|
hidlMemToken = m;
|
|
});
|
|
|
|
if (!transStatus.isOk()) {
|
|
ALOGE("[stream %d] hidl allocator failed at the transport: %s",
|
|
mElementaryPID, transStatus.description().c_str());
|
|
return false;
|
|
}
|
|
if (!success) {
|
|
ALOGE("[stream %d] hidl allocator failed", mElementaryPID);
|
|
return false;
|
|
}
|
|
newMem = mapMemory(hidlMemToken);
|
|
if (newMem == nullptr || newMem->getPointer() == nullptr) {
|
|
ALOGE("[stream %d] hidl failed to map memory", mElementaryPID);
|
|
return false;
|
|
}
|
|
|
|
newScrambledBuffer = new ABuffer(newMem->getPointer(), newMem->getSize());
|
|
|
|
if (mDescrambledBuffer != NULL) {
|
|
memcpy(newScrambledBuffer->data(),
|
|
mDescrambledBuffer->data(), mDescrambledBuffer->size());
|
|
newScrambledBuffer->setRange(0, mDescrambledBuffer->size());
|
|
} else {
|
|
newScrambledBuffer->setRange(0, 0);
|
|
}
|
|
mHidlMemory = newMem;
|
|
mDescrambledBuffer = newScrambledBuffer;
|
|
|
|
mDescramblerSrcBuffer.heapBase = hidlMemToken;
|
|
mDescramblerSrcBuffer.offset = 0ULL;
|
|
mDescramblerSrcBuffer.size = (uint64_t)neededSize;
|
|
|
|
ALOGD("[stream %d] created shared buffer for descrambling, size %zu",
|
|
mElementaryPID, neededSize);
|
|
} else {
|
|
// Align to multiples of 64K.
|
|
neededSize = (neededSize + 65535) & ~65535;
|
|
}
|
|
|
|
newBuffer = new ABuffer(neededSize);
|
|
if (mBuffer != NULL) {
|
|
memcpy(newBuffer->data(), mBuffer->data(), mBuffer->size());
|
|
newBuffer->setRange(0, mBuffer->size());
|
|
} else {
|
|
newBuffer->setRange(0, 0);
|
|
}
|
|
mBuffer = newBuffer;
|
|
return true;
|
|
}
|
|
|
|
status_t ATSParser::Stream::parse(
|
|
unsigned continuity_counter,
|
|
unsigned payload_unit_start_indicator,
|
|
unsigned transport_scrambling_control,
|
|
unsigned random_access_indicator,
|
|
ABitReader *br, SyncEvent *event) {
|
|
if (mQueue == NULL) {
|
|
return OK;
|
|
}
|
|
|
|
if (mExpectedContinuityCounter >= 0
|
|
&& (unsigned)mExpectedContinuityCounter != continuity_counter) {
|
|
ALOGI("discontinuity on stream pid 0x%04x", mElementaryPID);
|
|
|
|
mPayloadStarted = false;
|
|
mPesStartOffsets.clear();
|
|
mBuffer->setRange(0, 0);
|
|
mSubSamples.clear();
|
|
mExpectedContinuityCounter = -1;
|
|
|
|
#if 0
|
|
// Uncomment this if you'd rather see no corruption whatsoever on
|
|
// screen and suspend updates until we come across another IDR frame.
|
|
|
|
if (mStreamType == STREAMTYPE_H264) {
|
|
ALOGI("clearing video queue");
|
|
mQueue->clear(true /* clearFormat */);
|
|
}
|
|
#endif
|
|
|
|
if (!payload_unit_start_indicator) {
|
|
return OK;
|
|
}
|
|
}
|
|
|
|
mExpectedContinuityCounter = (continuity_counter + 1) & 0x0f;
|
|
|
|
if (payload_unit_start_indicator) {
|
|
off64_t offset = (event != NULL) ? event->getOffset() : 0;
|
|
if (mPayloadStarted) {
|
|
// Otherwise we run the danger of receiving the trailing bytes
|
|
// of a PES packet that we never saw the start of and assuming
|
|
// we have a a complete PES packet.
|
|
|
|
status_t err = flush(event);
|
|
|
|
if (err != OK) {
|
|
ALOGW("Error (%08x) happened while flushing; we simply discard "
|
|
"the PES packet and continue.", err);
|
|
}
|
|
}
|
|
|
|
mPayloadStarted = true;
|
|
// There should be at most 2 elements in |mPesStartOffsets|.
|
|
while (mPesStartOffsets.size() >= 2) {
|
|
mPesStartOffsets.erase(mPesStartOffsets.begin());
|
|
}
|
|
mPesStartOffsets.push_back(offset);
|
|
}
|
|
|
|
if (!mPayloadStarted) {
|
|
return OK;
|
|
}
|
|
|
|
size_t payloadSizeBits = br->numBitsLeft();
|
|
if (payloadSizeBits % 8 != 0u) {
|
|
ALOGE("Wrong value");
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
size_t neededSize = mBuffer->size() + payloadSizeBits / 8;
|
|
if (!ensureBufferCapacity(neededSize)) {
|
|
return NO_MEMORY;
|
|
}
|
|
|
|
memcpy(mBuffer->data() + mBuffer->size(), br->data(), payloadSizeBits / 8);
|
|
mBuffer->setRange(0, mBuffer->size() + payloadSizeBits / 8);
|
|
|
|
if (mScrambled) {
|
|
mSubSamples.push_back({payloadSizeBits / 8,
|
|
transport_scrambling_control, random_access_indicator});
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
bool ATSParser::Stream::isVideo() const {
|
|
switch (mStreamType) {
|
|
case STREAMTYPE_H264:
|
|
case STREAMTYPE_H264_ENCRYPTED:
|
|
case STREAMTYPE_MPEG1_VIDEO:
|
|
case STREAMTYPE_MPEG2_VIDEO:
|
|
case STREAMTYPE_MPEG4_VIDEO:
|
|
return true;
|
|
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool ATSParser::Stream::isAudio() const {
|
|
switch (mStreamType) {
|
|
case STREAMTYPE_MPEG1_AUDIO:
|
|
case STREAMTYPE_MPEG2_AUDIO:
|
|
case STREAMTYPE_MPEG2_AUDIO_ADTS:
|
|
case STREAMTYPE_LPCM_AC3:
|
|
case STREAMTYPE_AC3:
|
|
case STREAMTYPE_EAC3:
|
|
case STREAMTYPE_AAC_ENCRYPTED:
|
|
case STREAMTYPE_AC3_ENCRYPTED:
|
|
return true;
|
|
case STREAMTYPE_PES_PRIVATE_DATA:
|
|
return mStreamTypeExt == EXT_DESCRIPTOR_DVB_AC4;
|
|
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool ATSParser::Stream::isMeta() const {
|
|
if (mStreamType == STREAMTYPE_METADATA) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void ATSParser::Stream::signalDiscontinuity(
|
|
DiscontinuityType type, const sp<AMessage> &extra) {
|
|
mExpectedContinuityCounter = -1;
|
|
|
|
if (mQueue == NULL) {
|
|
return;
|
|
}
|
|
|
|
mPayloadStarted = false;
|
|
mPesStartOffsets.clear();
|
|
mEOSReached = false;
|
|
mBuffer->setRange(0, 0);
|
|
mSubSamples.clear();
|
|
|
|
bool clearFormat = false;
|
|
if (isAudio()) {
|
|
if (type & DISCONTINUITY_AUDIO_FORMAT) {
|
|
clearFormat = true;
|
|
}
|
|
} else {
|
|
if (type & DISCONTINUITY_VIDEO_FORMAT) {
|
|
clearFormat = true;
|
|
}
|
|
}
|
|
|
|
mQueue->clear(clearFormat);
|
|
|
|
if (type & DISCONTINUITY_TIME) {
|
|
uint64_t resumeAtPTS;
|
|
if (extra != NULL
|
|
&& extra->findInt64(
|
|
kATSParserKeyResumeAtPTS,
|
|
(int64_t *)&resumeAtPTS)) {
|
|
int64_t resumeAtMediaTimeUs =
|
|
mProgram->convertPTSToTimestamp(resumeAtPTS);
|
|
|
|
extra->setInt64("resume-at-mediaTimeUs", resumeAtMediaTimeUs);
|
|
}
|
|
}
|
|
|
|
if (mSource != NULL) {
|
|
sp<MetaData> meta = mSource->getFormat();
|
|
const char* mime;
|
|
if (clearFormat && meta != NULL && meta->findCString(kKeyMIMEType, &mime)
|
|
&& (!strncasecmp(mime, MEDIA_MIMETYPE_AUDIO_SCRAMBLED, 15)
|
|
|| !strncasecmp(mime, MEDIA_MIMETYPE_VIDEO_SCRAMBLED, 15))){
|
|
mSource->clear();
|
|
} else {
|
|
mSource->queueDiscontinuity(type, extra, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
void ATSParser::Stream::signalEOS(status_t finalResult) {
|
|
if (mSource != NULL) {
|
|
mSource->signalEOS(finalResult);
|
|
}
|
|
mEOSReached = true;
|
|
flush(NULL);
|
|
}
|
|
|
|
status_t ATSParser::Stream::parsePES(ABitReader *br, SyncEvent *event) {
|
|
const uint8_t *basePtr = br->data();
|
|
|
|
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;
|
|
}
|
|
|
|
unsigned stream_id = br->getBits(8);
|
|
ALOGV("stream_id = 0x%02x", stream_id);
|
|
|
|
unsigned PES_packet_length = br->getBits(16);
|
|
ALOGV("PES_packet_length = %u", PES_packet_length);
|
|
|
|
if (stream_id != 0xbc // program_stream_map
|
|
&& 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
|
|
if (br->getBits(2) != 2u) {
|
|
return ERROR_MALFORMED;
|
|
}
|
|
|
|
unsigned PES_scrambling_control = br->getBits(2);
|
|
ALOGV("PES_scrambling_control = %u", PES_scrambling_control);
|
|
|
|
MY_LOGV("PES_priority = %u", br->getBits(1));
|
|
MY_LOGV("data_alignment_indicator = %u", br->getBits(1));
|
|
MY_LOGV("copyright = %u", br->getBits(1));
|
|
MY_LOGV("original_or_copy = %u", 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);
|
|
|
|
MY_LOGV("PES_CRC_flag = %u", br->getBits(1));
|
|
MY_LOGV("PES_extension_flag = %u", 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 = 0x%016" PRIx64 " (%.2f)", PTS, PTS / 90000.0);
|
|
|
|
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);
|
|
MY_LOGV("ESCR_extension = %u", 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;
|
|
}
|
|
MY_LOGV("ES_rate = %u", br->getBits(22));
|
|
if (br->getBits(1) != 1u) {
|
|
return ERROR_MALFORMED;
|
|
}
|
|
|
|
optional_bytes_remaining -= 3;
|
|
}
|
|
|
|
br->skipBits(optional_bytes_remaining * 8);
|
|
|
|
// ES data follows.
|
|
int32_t pesOffset = br->data() - basePtr;
|
|
|
|
if (PES_packet_length != 0) {
|
|
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;
|
|
}
|
|
|
|
ALOGV("There's %u bytes of payload, PES_packet_length=%u, offset=%d",
|
|
dataLength, PES_packet_length, pesOffset);
|
|
|
|
onPayloadData(
|
|
PTS_DTS_flags, PTS, DTS, PES_scrambling_control,
|
|
br->data(), dataLength, pesOffset, event);
|
|
|
|
br->skipBits(dataLength * 8);
|
|
} else {
|
|
onPayloadData(
|
|
PTS_DTS_flags, PTS, DTS, PES_scrambling_control,
|
|
br->data(), br->numBitsLeft() / 8, pesOffset, event);
|
|
|
|
size_t payloadSizeBits = br->numBitsLeft();
|
|
if (payloadSizeBits % 8 != 0u) {
|
|
return ERROR_MALFORMED;
|
|
}
|
|
|
|
ALOGV("There's %zu bytes of payload, offset=%d",
|
|
payloadSizeBits / 8, pesOffset);
|
|
}
|
|
} 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 OK;
|
|
}
|
|
|
|
uint32_t ATSParser::Stream::getPesScramblingControl(
|
|
ABitReader *br, int32_t *pesOffset) {
|
|
unsigned packet_startcode_prefix = br->getBits(24);
|
|
|
|
ALOGV("packet_startcode_prefix = 0x%08x", packet_startcode_prefix);
|
|
|
|
if (packet_startcode_prefix != 1) {
|
|
ALOGV("unit does not start with startcode.");
|
|
return 0;
|
|
}
|
|
|
|
if (br->numBitsLeft() < 48) {
|
|
return 0;
|
|
}
|
|
|
|
unsigned stream_id = br->getBits(8);
|
|
ALOGV("stream_id = 0x%02x", stream_id);
|
|
|
|
br->skipBits(16); // PES_packet_length
|
|
|
|
if (stream_id != 0xbc // program_stream_map
|
|
&& 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
|
|
if (br->getBits(2) != 2u) {
|
|
return 0;
|
|
}
|
|
|
|
unsigned PES_scrambling_control = br->getBits(2);
|
|
ALOGV("PES_scrambling_control = %u", PES_scrambling_control);
|
|
|
|
if (PES_scrambling_control == 0) {
|
|
return 0;
|
|
}
|
|
|
|
br->skipBits(12); // don't care
|
|
|
|
unsigned PES_header_data_length = br->getBits(8);
|
|
ALOGV("PES_header_data_length = %u", PES_header_data_length);
|
|
|
|
if (PES_header_data_length * 8 > br->numBitsLeft()) {
|
|
return 0;
|
|
}
|
|
|
|
*pesOffset = 9 + PES_header_data_length;
|
|
ALOGD("found PES_scrambling_control=%d, PES offset=%d",
|
|
PES_scrambling_control, *pesOffset);
|
|
return PES_scrambling_control;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
status_t ATSParser::Stream::flushScrambled(SyncEvent *event) {
|
|
if (mDescrambler == NULL) {
|
|
ALOGE("received scrambled packets without descrambler!");
|
|
return UNKNOWN_ERROR;
|
|
}
|
|
|
|
if (mDescrambledBuffer == NULL || mHidlMemory == NULL) {
|
|
ALOGE("received scrambled packets without shared memory!");
|
|
|
|
return UNKNOWN_ERROR;
|
|
}
|
|
|
|
int32_t pesOffset = 0;
|
|
int32_t descrambleSubSamples = 0, descrambleBytes = 0;
|
|
uint32_t tsScramblingControl = 0, pesScramblingControl = 0;
|
|
|
|
// First, go over subsamples to find TS-level scrambling key id, and
|
|
// calculate how many subsample we need to descramble (assuming we don't
|
|
// have PES-level scrambling).
|
|
for (auto it = mSubSamples.begin(); it != mSubSamples.end(); it++) {
|
|
if (it->transport_scrambling_mode != 0) {
|
|
// TODO: handle keyId change, use the first non-zero keyId for now.
|
|
if (tsScramblingControl == 0) {
|
|
tsScramblingControl = it->transport_scrambling_mode;
|
|
}
|
|
}
|
|
if (tsScramblingControl == 0 || descrambleSubSamples == 0
|
|
|| !mQueue->isScrambled()) {
|
|
descrambleSubSamples++;
|
|
descrambleBytes += it->subSampleSize;
|
|
}
|
|
}
|
|
// If not scrambled at TS-level, check PES-level scrambling
|
|
if (tsScramblingControl == 0) {
|
|
ABitReader br(mBuffer->data(), mBuffer->size());
|
|
pesScramblingControl = getPesScramblingControl(&br, &pesOffset);
|
|
// If not scrambled at PES-level either, or scrambled at PES-level but
|
|
// requires output to remain scrambled, we don't need to descramble
|
|
// anything.
|
|
if (pesScramblingControl == 0 || mQueue->isScrambled()) {
|
|
descrambleSubSamples = 0;
|
|
descrambleBytes = 0;
|
|
}
|
|
}
|
|
|
|
uint32_t sctrl = tsScramblingControl != 0 ?
|
|
tsScramblingControl : pesScramblingControl;
|
|
if (mQueue->isScrambled()) {
|
|
sctrl |= DescramblerPlugin::kScrambling_Flag_PesHeader;
|
|
}
|
|
|
|
// Perform the 1st pass descrambling if needed
|
|
if (descrambleBytes > 0) {
|
|
memcpy(mDescrambledBuffer->data(), mBuffer->data(), descrambleBytes);
|
|
mDescrambledBuffer->setRange(0, mBuffer->size());
|
|
|
|
hidl_vec<SubSample> subSamples;
|
|
subSamples.resize(descrambleSubSamples);
|
|
|
|
int32_t i = 0;
|
|
for (auto it = mSubSamples.begin();
|
|
it != mSubSamples.end() && i < descrambleSubSamples; it++, i++) {
|
|
if (it->transport_scrambling_mode != 0 || pesScramblingControl != 0) {
|
|
subSamples[i].numBytesOfClearData = 0;
|
|
subSamples[i].numBytesOfEncryptedData = it->subSampleSize;
|
|
} else {
|
|
subSamples[i].numBytesOfClearData = it->subSampleSize;
|
|
subSamples[i].numBytesOfEncryptedData = 0;
|
|
}
|
|
}
|
|
|
|
// If scrambled at PES-level, PES header is in the clear
|
|
if (pesScramblingControl != 0) {
|
|
subSamples[0].numBytesOfClearData = pesOffset;
|
|
subSamples[0].numBytesOfEncryptedData -= pesOffset;
|
|
}
|
|
|
|
Status status = Status::OK;
|
|
uint32_t bytesWritten = 0;
|
|
hidl_string detailedError;
|
|
|
|
DestinationBuffer dstBuffer;
|
|
dstBuffer.type = BufferType::SHARED_MEMORY;
|
|
dstBuffer.nonsecureMemory = mDescramblerSrcBuffer;
|
|
|
|
auto returnVoid = mDescrambler->descramble(
|
|
(ScramblingControl) sctrl,
|
|
subSamples,
|
|
mDescramblerSrcBuffer,
|
|
0 /*srcOffset*/,
|
|
dstBuffer,
|
|
0 /*dstOffset*/,
|
|
[&status, &bytesWritten, &detailedError] (
|
|
Status _status, uint32_t _bytesWritten,
|
|
const hidl_string& _detailedError) {
|
|
status = _status;
|
|
bytesWritten = _bytesWritten;
|
|
detailedError = _detailedError;
|
|
});
|
|
|
|
if (!returnVoid.isOk() || status != Status::OK) {
|
|
ALOGE("[stream %d] descramble failed, trans=%s, status=%d",
|
|
mElementaryPID, returnVoid.description().c_str(), status);
|
|
return UNKNOWN_ERROR;
|
|
}
|
|
|
|
ALOGV("[stream %d] descramble succeeded, %d bytes",
|
|
mElementaryPID, bytesWritten);
|
|
|
|
// Set descrambleBytes to the returned result.
|
|
// Note that this might be smaller than the total length of input data.
|
|
// (eg. when we're descrambling the PES header portion of a secure stream,
|
|
// the plugin might cut it off right after the PES header.)
|
|
descrambleBytes = bytesWritten;
|
|
}
|
|
|
|
// |buffer| points to the buffer from which we'd parse the PES header.
|
|
// When the output stream is scrambled, it points to mDescrambledBuffer
|
|
// (unless all packets in this PES are actually clear, in which case,
|
|
// it points to mBuffer since we never copied into mDescrambledBuffer).
|
|
// When the output stream is clear, it points to mBuffer, and we'll
|
|
// copy all descrambled data back to mBuffer.
|
|
sp<ABuffer> buffer = mBuffer;
|
|
if (mQueue->isScrambled()) {
|
|
// Queue subSample info for scrambled queue
|
|
sp<ABuffer> clearSizesBuffer = new ABuffer(mSubSamples.size() * 4);
|
|
sp<ABuffer> encSizesBuffer = new ABuffer(mSubSamples.size() * 4);
|
|
int32_t *clearSizePtr = (int32_t*)clearSizesBuffer->data();
|
|
int32_t *encSizePtr = (int32_t*)encSizesBuffer->data();
|
|
int32_t isSync = 0;
|
|
int32_t i = 0;
|
|
for (auto it = mSubSamples.begin();
|
|
it != mSubSamples.end(); it++, i++) {
|
|
if ((it->transport_scrambling_mode == 0
|
|
&& pesScramblingControl == 0)) {
|
|
clearSizePtr[i] = it->subSampleSize;
|
|
encSizePtr[i] = 0;
|
|
} else {
|
|
clearSizePtr[i] = 0;
|
|
encSizePtr[i] = it->subSampleSize;
|
|
}
|
|
isSync |= it->random_access_indicator;
|
|
}
|
|
|
|
// If scrambled at PES-level, PES header is in the clear
|
|
if (pesScramblingControl != 0) {
|
|
clearSizePtr[0] = pesOffset;
|
|
encSizePtr[0] -= pesOffset;
|
|
}
|
|
// Pass the original TS subsample size now. The PES header adjust
|
|
// will be applied when the scrambled AU is dequeued.
|
|
// Note that if descrambleBytes is 0, it means this PES contains only
|
|
// all ts packets, leadingClearBytes is entire buffer size.
|
|
mQueue->appendScrambledData(
|
|
mBuffer->data(), mBuffer->size(),
|
|
(descrambleBytes > 0) ? descrambleBytes : mBuffer->size(),
|
|
sctrl, isSync, clearSizesBuffer, encSizesBuffer);
|
|
|
|
if (descrambleBytes > 0) {
|
|
buffer = mDescrambledBuffer;
|
|
}
|
|
} else {
|
|
memcpy(mBuffer->data(), mDescrambledBuffer->data(), descrambleBytes);
|
|
}
|
|
|
|
ABitReader br(buffer->data(), buffer->size());
|
|
status_t err = parsePES(&br, event);
|
|
|
|
if (err != OK) {
|
|
ALOGE("[stream %d] failed to parse descrambled PES, err=%d",
|
|
mElementaryPID, err);
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
|
|
status_t ATSParser::Stream::flush(SyncEvent *event) {
|
|
if (mBuffer == NULL || mBuffer->size() == 0) {
|
|
return OK;
|
|
}
|
|
|
|
ALOGV("flushing stream 0x%04x size = %zu", mElementaryPID, mBuffer->size());
|
|
|
|
status_t err = OK;
|
|
if (mScrambled) {
|
|
err = flushScrambled(event);
|
|
mSubSamples.clear();
|
|
} else {
|
|
ABitReader br(mBuffer->data(), mBuffer->size());
|
|
err = parsePES(&br, event);
|
|
}
|
|
|
|
mBuffer->setRange(0, 0);
|
|
|
|
return err;
|
|
}
|
|
|
|
void ATSParser::Stream::addAudioPresentations(const sp<ABuffer> &buffer) {
|
|
std::ostringstream outStream(std::ios::out);
|
|
serializeAudioPresentations(mAudioPresentations, &outStream);
|
|
sp<ABuffer> ap = ABuffer::CreateAsCopy(outStream.str().data(), outStream.str().size());
|
|
buffer->meta()->setBuffer("audio-presentation-info", ap);
|
|
}
|
|
|
|
void ATSParser::Stream::onPayloadData(
|
|
unsigned PTS_DTS_flags, uint64_t PTS, uint64_t /* DTS */,
|
|
unsigned PES_scrambling_control,
|
|
const uint8_t *data, size_t size,
|
|
int32_t payloadOffset, SyncEvent *event) {
|
|
#if 0
|
|
ALOGI("payload streamType 0x%02x, PTS = 0x%016llx, dPTS = %lld",
|
|
mStreamType,
|
|
PTS,
|
|
(int64_t)PTS - mPrevPTS);
|
|
mPrevPTS = PTS;
|
|
#endif
|
|
|
|
ALOGV("onPayloadData mStreamType=0x%02x size: %zu", mStreamType, size);
|
|
|
|
int64_t timeUs = 0LL; // no presentation timestamp available.
|
|
if (PTS_DTS_flags == 2 || PTS_DTS_flags == 3) {
|
|
timeUs = mProgram->convertPTSToTimestamp(PTS);
|
|
}
|
|
|
|
status_t err = mQueue->appendData(
|
|
data, size, timeUs, payloadOffset, PES_scrambling_control);
|
|
|
|
if (mEOSReached) {
|
|
mQueue->signalEOS();
|
|
}
|
|
|
|
if (err != OK) {
|
|
return;
|
|
}
|
|
|
|
sp<ABuffer> accessUnit;
|
|
bool found = false;
|
|
while ((accessUnit = mQueue->dequeueAccessUnit()) != NULL) {
|
|
if (mSource == NULL) {
|
|
sp<MetaData> meta = mQueue->getFormat();
|
|
|
|
if (meta != NULL) {
|
|
ALOGV("Stream PID 0x%08x of type 0x%02x now has data.",
|
|
mElementaryPID, mStreamType);
|
|
|
|
const char *mime;
|
|
if (meta->findCString(kKeyMIMEType, &mime)
|
|
&& !strcasecmp(mime, MEDIA_MIMETYPE_VIDEO_AVC)) {
|
|
int32_t sync = 0;
|
|
if (!accessUnit->meta()->findInt32("isSync", &sync) || !sync) {
|
|
continue;
|
|
}
|
|
}
|
|
mSource = new AnotherPacketSource(meta);
|
|
if (mAudioPresentations.size() > 0) {
|
|
addAudioPresentations(accessUnit);
|
|
}
|
|
mSource->queueAccessUnit(accessUnit);
|
|
ALOGV("onPayloadData: created AnotherPacketSource PID 0x%08x of type 0x%02x",
|
|
mElementaryPID, mStreamType);
|
|
}
|
|
} else if (mQueue->getFormat() != NULL) {
|
|
// After a discontinuity we invalidate the queue's format
|
|
// and won't enqueue any access units to the source until
|
|
// the queue has reestablished the new format.
|
|
|
|
if (mSource->getFormat() == NULL) {
|
|
mSource->setFormat(mQueue->getFormat());
|
|
}
|
|
if (mAudioPresentations.size() > 0) {
|
|
addAudioPresentations(accessUnit);
|
|
}
|
|
mSource->queueAccessUnit(accessUnit);
|
|
}
|
|
|
|
// Every access unit has a pesStartOffset queued in |mPesStartOffsets|.
|
|
off64_t pesStartOffset = -1;
|
|
if (!mPesStartOffsets.empty()) {
|
|
pesStartOffset = *mPesStartOffsets.begin();
|
|
mPesStartOffsets.erase(mPesStartOffsets.begin());
|
|
}
|
|
|
|
if (pesStartOffset >= 0 && (event != NULL) && !found && mQueue->getFormat() != NULL) {
|
|
int32_t sync = 0;
|
|
if (accessUnit->meta()->findInt32("isSync", &sync) && sync) {
|
|
int64_t timeUs;
|
|
if (accessUnit->meta()->findInt64("timeUs", &timeUs)) {
|
|
found = true;
|
|
event->init(pesStartOffset, mSource, timeUs, getSourceType());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
ATSParser::SourceType ATSParser::Stream::getSourceType() {
|
|
if (isVideo()) {
|
|
return VIDEO;
|
|
} else if (isAudio()) {
|
|
return AUDIO;
|
|
} else if (isMeta()) {
|
|
return META;
|
|
}
|
|
return NUM_SOURCE_TYPES;
|
|
}
|
|
|
|
sp<AnotherPacketSource> ATSParser::Stream::getSource(SourceType type) {
|
|
switch (type) {
|
|
case VIDEO:
|
|
{
|
|
if (isVideo()) {
|
|
return mSource;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case AUDIO:
|
|
{
|
|
if (isAudio()) {
|
|
return mSource;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case META:
|
|
{
|
|
if (isMeta()) {
|
|
return mSource;
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void ATSParser::Stream::setCasInfo(
|
|
int32_t systemId, const sp<IDescrambler> &descrambler,
|
|
const std::vector<uint8_t> &sessionId) {
|
|
if (mSource != NULL && mDescrambler == NULL && descrambler != NULL) {
|
|
signalDiscontinuity(DISCONTINUITY_FORMAT_ONLY, NULL);
|
|
mDescrambler = descrambler;
|
|
if (mQueue->isScrambled()) {
|
|
mQueue->setCasInfo(systemId, sessionId);
|
|
}
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
ATSParser::ATSParser(uint32_t flags)
|
|
: mFlags(flags),
|
|
mAbsoluteTimeAnchorUs(-1LL),
|
|
mTimeOffsetValid(false),
|
|
mTimeOffsetUs(0LL),
|
|
mLastRecoveredPTS(-1LL),
|
|
mNumTSPacketsParsed(0),
|
|
mNumPCRs(0) {
|
|
mPSISections.add(0 /* PID */, new PSISection);
|
|
mCasManager = new CasManager();
|
|
}
|
|
|
|
ATSParser::~ATSParser() {
|
|
}
|
|
|
|
status_t ATSParser::feedTSPacket(const void *data, size_t size,
|
|
SyncEvent *event) {
|
|
if (size != kTSPacketSize) {
|
|
ALOGE("Wrong TS packet size");
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
ABitReader br((const uint8_t *)data, kTSPacketSize);
|
|
return parseTS(&br, event);
|
|
}
|
|
|
|
status_t ATSParser::setMediaCas(const sp<ICas> &cas) {
|
|
status_t err = mCasManager->setMediaCas(cas);
|
|
if (err != OK) {
|
|
return err;
|
|
}
|
|
for (size_t i = 0; i < mPrograms.size(); ++i) {
|
|
mPrograms.editItemAt(i)->updateCasSessions();
|
|
}
|
|
return OK;
|
|
}
|
|
|
|
void ATSParser::signalDiscontinuity(
|
|
DiscontinuityType type, const sp<AMessage> &extra) {
|
|
int64_t mediaTimeUs;
|
|
if ((type & DISCONTINUITY_TIME) && extra != NULL) {
|
|
if (extra->findInt64(kATSParserKeyMediaTimeUs, &mediaTimeUs)) {
|
|
mAbsoluteTimeAnchorUs = mediaTimeUs;
|
|
}
|
|
if ((mFlags & TS_TIMESTAMPS_ARE_ABSOLUTE)
|
|
&& extra->findInt64(
|
|
kATSParserKeyRecentMediaTimeUs, &mediaTimeUs)) {
|
|
if (mAbsoluteTimeAnchorUs >= 0LL) {
|
|
mediaTimeUs -= mAbsoluteTimeAnchorUs;
|
|
}
|
|
if (mTimeOffsetValid) {
|
|
mediaTimeUs -= mTimeOffsetUs;
|
|
}
|
|
mLastRecoveredPTS = (mediaTimeUs * 9) / 100;
|
|
}
|
|
} else if (type == DISCONTINUITY_ABSOLUTE_TIME) {
|
|
int64_t timeUs;
|
|
if (!extra->findInt64("timeUs", &timeUs)) {
|
|
ALOGE("timeUs not found");
|
|
return;
|
|
}
|
|
|
|
if (!mPrograms.empty()) {
|
|
ALOGE("mPrograms is not empty");
|
|
return;
|
|
}
|
|
mAbsoluteTimeAnchorUs = timeUs;
|
|
return;
|
|
} else if (type == DISCONTINUITY_TIME_OFFSET) {
|
|
int64_t offset;
|
|
if (!extra->findInt64("offset", &offset)) {
|
|
ALOGE("offset not found");
|
|
return;
|
|
}
|
|
|
|
mTimeOffsetValid = true;
|
|
mTimeOffsetUs = offset;
|
|
return;
|
|
}
|
|
|
|
for (size_t i = 0; i < mPrograms.size(); ++i) {
|
|
mPrograms.editItemAt(i)->signalDiscontinuity(type, extra);
|
|
}
|
|
}
|
|
|
|
void ATSParser::signalEOS(status_t finalResult) {
|
|
if (finalResult == (status_t) OK) {
|
|
ALOGE("finalResult not OK");
|
|
return;
|
|
}
|
|
|
|
for (size_t i = 0; i < mPrograms.size(); ++i) {
|
|
mPrograms.editItemAt(i)->signalEOS(finalResult);
|
|
}
|
|
}
|
|
|
|
void ATSParser::parseProgramAssociationTable(ABitReader *br) {
|
|
unsigned table_id = br->getBits(8);
|
|
ALOGV(" table_id = %u", table_id);
|
|
if (table_id != 0x00u) {
|
|
ALOGE("PAT data error!");
|
|
return ;
|
|
}
|
|
unsigned section_syntax_indictor = br->getBits(1);
|
|
ALOGV(" section_syntax_indictor = %u", section_syntax_indictor);
|
|
|
|
br->skipBits(1); // '0'
|
|
MY_LOGV(" reserved = %u", br->getBits(2));
|
|
|
|
unsigned section_length = br->getBits(12);
|
|
ALOGV(" section_length = %u", section_length);
|
|
|
|
MY_LOGV(" transport_stream_id = %u", br->getBits(16));
|
|
MY_LOGV(" reserved = %u", br->getBits(2));
|
|
MY_LOGV(" version_number = %u", br->getBits(5));
|
|
MY_LOGV(" current_next_indicator = %u", br->getBits(1));
|
|
MY_LOGV(" section_number = %u", br->getBits(8));
|
|
MY_LOGV(" last_section_number = %u", br->getBits(8));
|
|
|
|
size_t numProgramBytes = (section_length - 5 /* header */ - 4 /* crc */);
|
|
|
|
for (size_t i = 0; i < numProgramBytes / 4; ++i) {
|
|
unsigned program_number = br->getBits(16);
|
|
ALOGV(" program_number = %u", program_number);
|
|
|
|
MY_LOGV(" reserved = %u", br->getBits(3));
|
|
|
|
if (program_number == 0) {
|
|
MY_LOGV(" network_PID = 0x%04x", br->getBits(13));
|
|
} else {
|
|
unsigned programMapPID = br->getBits(13);
|
|
|
|
ALOGV(" program_map_PID = 0x%04x", programMapPID);
|
|
|
|
bool found = false;
|
|
for (size_t index = 0; index < mPrograms.size(); ++index) {
|
|
const sp<Program> &program = mPrograms.itemAt(index);
|
|
|
|
if (program->number() == program_number) {
|
|
program->updateProgramMapPID(programMapPID);
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!found) {
|
|
mPrograms.push(
|
|
new Program(this, program_number, programMapPID, mLastRecoveredPTS));
|
|
if (mSampleAesKeyItem != NULL) {
|
|
mPrograms.top()->signalNewSampleAesKey(mSampleAesKeyItem);
|
|
}
|
|
}
|
|
|
|
if (mPSISections.indexOfKey(programMapPID) < 0) {
|
|
mPSISections.add(programMapPID, new PSISection);
|
|
}
|
|
}
|
|
}
|
|
|
|
MY_LOGV(" CRC = 0x%08x", br->getBits(32));
|
|
}
|
|
|
|
status_t ATSParser::parsePID(
|
|
ABitReader *br, unsigned PID,
|
|
unsigned continuity_counter,
|
|
unsigned payload_unit_start_indicator,
|
|
unsigned transport_scrambling_control,
|
|
unsigned random_access_indicator,
|
|
SyncEvent *event) {
|
|
ssize_t sectionIndex = mPSISections.indexOfKey(PID);
|
|
|
|
if (sectionIndex >= 0) {
|
|
sp<PSISection> section = mPSISections.valueAt(sectionIndex);
|
|
|
|
if (payload_unit_start_indicator) {
|
|
if (!section->isEmpty()) {
|
|
ALOGW("parsePID encounters payload_unit_start_indicator when section is not empty");
|
|
section->clear();
|
|
}
|
|
|
|
unsigned skip = br->getBits(8);
|
|
section->setSkipBytes(skip + 1); // skip filler bytes + pointer field itself
|
|
br->skipBits(skip * 8);
|
|
}
|
|
|
|
if (br->numBitsLeft() % 8 != 0) {
|
|
return ERROR_MALFORMED;
|
|
}
|
|
status_t err = section->append(br->data(), br->numBitsLeft() / 8);
|
|
|
|
if (err != OK) {
|
|
return err;
|
|
}
|
|
|
|
if (!section->isComplete()) {
|
|
return OK;
|
|
}
|
|
|
|
if (!section->isCRCOkay()) {
|
|
return BAD_VALUE;
|
|
}
|
|
ABitReader sectionBits(section->data(), section->size());
|
|
|
|
if (PID == 0) {
|
|
parseProgramAssociationTable(§ionBits);
|
|
} else {
|
|
bool handled = false;
|
|
for (size_t i = 0; i < mPrograms.size(); ++i) {
|
|
status_t err;
|
|
if (!mPrograms.editItemAt(i)->parsePSISection(
|
|
PID, §ionBits, &err)) {
|
|
continue;
|
|
}
|
|
|
|
if (err != OK) {
|
|
return err;
|
|
}
|
|
|
|
handled = true;
|
|
break;
|
|
}
|
|
|
|
if (!handled) {
|
|
mPSISections.removeItem(PID);
|
|
section.clear();
|
|
}
|
|
}
|
|
|
|
if (section != NULL) {
|
|
section->clear();
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
bool handled = false;
|
|
for (size_t i = 0; i < mPrograms.size(); ++i) {
|
|
status_t err;
|
|
if (mPrograms.editItemAt(i)->parsePID(
|
|
PID, continuity_counter,
|
|
payload_unit_start_indicator,
|
|
transport_scrambling_control,
|
|
random_access_indicator,
|
|
br, &err, event)) {
|
|
if (err != OK) {
|
|
return err;
|
|
}
|
|
|
|
handled = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!handled) {
|
|
handled = mCasManager->parsePID(br, PID);
|
|
}
|
|
|
|
if (!handled) {
|
|
ALOGV("PID 0x%04x not handled.", PID);
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
status_t ATSParser::parseAdaptationField(
|
|
ABitReader *br, unsigned PID, unsigned *random_access_indicator) {
|
|
*random_access_indicator = 0;
|
|
unsigned adaptation_field_length = br->getBits(8);
|
|
|
|
if (adaptation_field_length > 0) {
|
|
if (adaptation_field_length * 8 > br->numBitsLeft()) {
|
|
ALOGV("Adaptation field should be included in a single TS packet.");
|
|
return ERROR_MALFORMED;
|
|
}
|
|
|
|
unsigned discontinuity_indicator = br->getBits(1);
|
|
|
|
if (discontinuity_indicator) {
|
|
ALOGV("PID 0x%04x: discontinuity_indicator = 1 (!!!)", PID);
|
|
}
|
|
|
|
*random_access_indicator = br->getBits(1);
|
|
if (*random_access_indicator) {
|
|
ALOGV("PID 0x%04x: random_access_indicator = 1", PID);
|
|
}
|
|
|
|
unsigned elementary_stream_priority_indicator = br->getBits(1);
|
|
if (elementary_stream_priority_indicator) {
|
|
ALOGV("PID 0x%04x: elementary_stream_priority_indicator = 1", PID);
|
|
}
|
|
|
|
unsigned PCR_flag = br->getBits(1);
|
|
|
|
size_t numBitsRead = 4;
|
|
|
|
if (PCR_flag) {
|
|
if (adaptation_field_length * 8 < 52) {
|
|
return ERROR_MALFORMED;
|
|
}
|
|
br->skipBits(4);
|
|
uint64_t PCR_base = br->getBits(32);
|
|
PCR_base = (PCR_base << 1) | br->getBits(1);
|
|
|
|
br->skipBits(6);
|
|
unsigned PCR_ext = br->getBits(9);
|
|
|
|
// The number of bytes from the start of the current
|
|
// MPEG2 transport stream packet up and including
|
|
// the final byte of this PCR_ext field.
|
|
size_t byteOffsetFromStartOfTSPacket =
|
|
(188 - br->numBitsLeft() / 8);
|
|
|
|
uint64_t PCR = PCR_base * 300 + PCR_ext;
|
|
|
|
ALOGV("PID 0x%04x: PCR = 0x%016" PRIx64 " (%.2f)",
|
|
PID, PCR, PCR / 27E6);
|
|
|
|
// The number of bytes received by this parser up to and
|
|
// including the final byte of this PCR_ext field.
|
|
uint64_t byteOffsetFromStart =
|
|
uint64_t(mNumTSPacketsParsed) * 188 + byteOffsetFromStartOfTSPacket;
|
|
|
|
for (size_t i = 0; i < mPrograms.size(); ++i) {
|
|
updatePCR(PID, PCR, byteOffsetFromStart);
|
|
}
|
|
|
|
numBitsRead += 52;
|
|
}
|
|
|
|
br->skipBits(adaptation_field_length * 8 - numBitsRead);
|
|
}
|
|
return OK;
|
|
}
|
|
|
|
status_t ATSParser::parseTS(ABitReader *br, SyncEvent *event) {
|
|
ALOGV("---");
|
|
|
|
unsigned sync_byte = br->getBits(8);
|
|
if (sync_byte != 0x47u) {
|
|
ALOGE("[error] parseTS: return error as sync_byte=0x%x", sync_byte);
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
if (br->getBits(1)) { // transport_error_indicator
|
|
// silently ignore.
|
|
return OK;
|
|
}
|
|
|
|
unsigned payload_unit_start_indicator = br->getBits(1);
|
|
ALOGV("payload_unit_start_indicator = %u", payload_unit_start_indicator);
|
|
|
|
MY_LOGV("transport_priority = %u", br->getBits(1));
|
|
|
|
unsigned PID = br->getBits(13);
|
|
ALOGV("PID = 0x%04x", PID);
|
|
|
|
unsigned transport_scrambling_control = br->getBits(2);
|
|
ALOGV("transport_scrambling_control = %u", transport_scrambling_control);
|
|
|
|
unsigned adaptation_field_control = br->getBits(2);
|
|
ALOGV("adaptation_field_control = %u", adaptation_field_control);
|
|
|
|
unsigned continuity_counter = br->getBits(4);
|
|
ALOGV("PID = 0x%04x, continuity_counter = %u", PID, continuity_counter);
|
|
|
|
// ALOGI("PID = 0x%04x, continuity_counter = %u", PID, continuity_counter);
|
|
|
|
status_t err = OK;
|
|
|
|
unsigned random_access_indicator = 0;
|
|
if (adaptation_field_control == 2 || adaptation_field_control == 3) {
|
|
err = parseAdaptationField(br, PID, &random_access_indicator);
|
|
}
|
|
if (err == OK) {
|
|
if (adaptation_field_control == 1 || adaptation_field_control == 3) {
|
|
err = parsePID(br, PID, continuity_counter,
|
|
payload_unit_start_indicator,
|
|
transport_scrambling_control,
|
|
random_access_indicator,
|
|
event);
|
|
}
|
|
}
|
|
|
|
++mNumTSPacketsParsed;
|
|
|
|
return err;
|
|
}
|
|
|
|
sp<AnotherPacketSource> ATSParser::getSource(SourceType type) {
|
|
sp<AnotherPacketSource> firstSourceFound;
|
|
for (size_t i = 0; i < mPrograms.size(); ++i) {
|
|
const sp<Program> &program = mPrograms.editItemAt(i);
|
|
sp<AnotherPacketSource> source = program->getSource(type);
|
|
if (source == NULL) {
|
|
continue;
|
|
}
|
|
if (firstSourceFound == NULL) {
|
|
firstSourceFound = source;
|
|
}
|
|
// Prefer programs with both audio/video
|
|
switch (type) {
|
|
case VIDEO: {
|
|
if (program->hasSource(AUDIO)) {
|
|
return source;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case AUDIO: {
|
|
if (program->hasSource(VIDEO)) {
|
|
return source;
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
return source;
|
|
}
|
|
}
|
|
|
|
return firstSourceFound;
|
|
}
|
|
|
|
bool ATSParser::hasSource(SourceType type) const {
|
|
for (size_t i = 0; i < mPrograms.size(); ++i) {
|
|
const sp<Program> &program = mPrograms.itemAt(i);
|
|
if (program->hasSource(type)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool ATSParser::PTSTimeDeltaEstablished() {
|
|
if (mPrograms.isEmpty()) {
|
|
return false;
|
|
}
|
|
|
|
return mPrograms.editItemAt(0)->PTSTimeDeltaEstablished();
|
|
}
|
|
|
|
int64_t ATSParser::getFirstPTSTimeUs() {
|
|
for (size_t i = 0; i < mPrograms.size(); ++i) {
|
|
sp<ATSParser::Program> program = mPrograms.itemAt(i);
|
|
if (program->PTSTimeDeltaEstablished()) {
|
|
return (program->firstPTS() * 100) / 9;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
__attribute__((no_sanitize("integer")))
|
|
void ATSParser::updatePCR(
|
|
unsigned /* PID */, uint64_t PCR, uint64_t byteOffsetFromStart) {
|
|
ALOGV("PCR 0x%016" PRIx64 " @ %" PRIx64, PCR, byteOffsetFromStart);
|
|
|
|
if (mNumPCRs == 2) {
|
|
mPCR[0] = mPCR[1];
|
|
mPCRBytes[0] = mPCRBytes[1];
|
|
mSystemTimeUs[0] = mSystemTimeUs[1];
|
|
mNumPCRs = 1;
|
|
}
|
|
|
|
mPCR[mNumPCRs] = PCR;
|
|
mPCRBytes[mNumPCRs] = byteOffsetFromStart;
|
|
mSystemTimeUs[mNumPCRs] = ALooper::GetNowUs();
|
|
|
|
++mNumPCRs;
|
|
|
|
if (mNumPCRs == 2) {
|
|
/* Unsigned overflow here */
|
|
double transportRate =
|
|
(mPCRBytes[1] - mPCRBytes[0]) * 27E6 / (mPCR[1] - mPCR[0]);
|
|
|
|
ALOGV("transportRate = %.2f bytes/sec", transportRate);
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
// CRC32 used for PSI section. The table was generated by following command:
|
|
// $ python pycrc.py --model crc-32-mpeg --algorithm table-driven --generate c
|
|
// Visit http://www.tty1.net/pycrc/index_en.html for more details.
|
|
uint32_t ATSParser::PSISection::CRC_TABLE[] = {
|
|
0x00000000, 0x04c11db7, 0x09823b6e, 0x0d4326d9,
|
|
0x130476dc, 0x17c56b6b, 0x1a864db2, 0x1e475005,
|
|
0x2608edb8, 0x22c9f00f, 0x2f8ad6d6, 0x2b4bcb61,
|
|
0x350c9b64, 0x31cd86d3, 0x3c8ea00a, 0x384fbdbd,
|
|
0x4c11db70, 0x48d0c6c7, 0x4593e01e, 0x4152fda9,
|
|
0x5f15adac, 0x5bd4b01b, 0x569796c2, 0x52568b75,
|
|
0x6a1936c8, 0x6ed82b7f, 0x639b0da6, 0x675a1011,
|
|
0x791d4014, 0x7ddc5da3, 0x709f7b7a, 0x745e66cd,
|
|
0x9823b6e0, 0x9ce2ab57, 0x91a18d8e, 0x95609039,
|
|
0x8b27c03c, 0x8fe6dd8b, 0x82a5fb52, 0x8664e6e5,
|
|
0xbe2b5b58, 0xbaea46ef, 0xb7a96036, 0xb3687d81,
|
|
0xad2f2d84, 0xa9ee3033, 0xa4ad16ea, 0xa06c0b5d,
|
|
0xd4326d90, 0xd0f37027, 0xddb056fe, 0xd9714b49,
|
|
0xc7361b4c, 0xc3f706fb, 0xceb42022, 0xca753d95,
|
|
0xf23a8028, 0xf6fb9d9f, 0xfbb8bb46, 0xff79a6f1,
|
|
0xe13ef6f4, 0xe5ffeb43, 0xe8bccd9a, 0xec7dd02d,
|
|
0x34867077, 0x30476dc0, 0x3d044b19, 0x39c556ae,
|
|
0x278206ab, 0x23431b1c, 0x2e003dc5, 0x2ac12072,
|
|
0x128e9dcf, 0x164f8078, 0x1b0ca6a1, 0x1fcdbb16,
|
|
0x018aeb13, 0x054bf6a4, 0x0808d07d, 0x0cc9cdca,
|
|
0x7897ab07, 0x7c56b6b0, 0x71159069, 0x75d48dde,
|
|
0x6b93dddb, 0x6f52c06c, 0x6211e6b5, 0x66d0fb02,
|
|
0x5e9f46bf, 0x5a5e5b08, 0x571d7dd1, 0x53dc6066,
|
|
0x4d9b3063, 0x495a2dd4, 0x44190b0d, 0x40d816ba,
|
|
0xaca5c697, 0xa864db20, 0xa527fdf9, 0xa1e6e04e,
|
|
0xbfa1b04b, 0xbb60adfc, 0xb6238b25, 0xb2e29692,
|
|
0x8aad2b2f, 0x8e6c3698, 0x832f1041, 0x87ee0df6,
|
|
0x99a95df3, 0x9d684044, 0x902b669d, 0x94ea7b2a,
|
|
0xe0b41de7, 0xe4750050, 0xe9362689, 0xedf73b3e,
|
|
0xf3b06b3b, 0xf771768c, 0xfa325055, 0xfef34de2,
|
|
0xc6bcf05f, 0xc27dede8, 0xcf3ecb31, 0xcbffd686,
|
|
0xd5b88683, 0xd1799b34, 0xdc3abded, 0xd8fba05a,
|
|
0x690ce0ee, 0x6dcdfd59, 0x608edb80, 0x644fc637,
|
|
0x7a089632, 0x7ec98b85, 0x738aad5c, 0x774bb0eb,
|
|
0x4f040d56, 0x4bc510e1, 0x46863638, 0x42472b8f,
|
|
0x5c007b8a, 0x58c1663d, 0x558240e4, 0x51435d53,
|
|
0x251d3b9e, 0x21dc2629, 0x2c9f00f0, 0x285e1d47,
|
|
0x36194d42, 0x32d850f5, 0x3f9b762c, 0x3b5a6b9b,
|
|
0x0315d626, 0x07d4cb91, 0x0a97ed48, 0x0e56f0ff,
|
|
0x1011a0fa, 0x14d0bd4d, 0x19939b94, 0x1d528623,
|
|
0xf12f560e, 0xf5ee4bb9, 0xf8ad6d60, 0xfc6c70d7,
|
|
0xe22b20d2, 0xe6ea3d65, 0xeba91bbc, 0xef68060b,
|
|
0xd727bbb6, 0xd3e6a601, 0xdea580d8, 0xda649d6f,
|
|
0xc423cd6a, 0xc0e2d0dd, 0xcda1f604, 0xc960ebb3,
|
|
0xbd3e8d7e, 0xb9ff90c9, 0xb4bcb610, 0xb07daba7,
|
|
0xae3afba2, 0xaafbe615, 0xa7b8c0cc, 0xa379dd7b,
|
|
0x9b3660c6, 0x9ff77d71, 0x92b45ba8, 0x9675461f,
|
|
0x8832161a, 0x8cf30bad, 0x81b02d74, 0x857130c3,
|
|
0x5d8a9099, 0x594b8d2e, 0x5408abf7, 0x50c9b640,
|
|
0x4e8ee645, 0x4a4ffbf2, 0x470cdd2b, 0x43cdc09c,
|
|
0x7b827d21, 0x7f436096, 0x7200464f, 0x76c15bf8,
|
|
0x68860bfd, 0x6c47164a, 0x61043093, 0x65c52d24,
|
|
0x119b4be9, 0x155a565e, 0x18197087, 0x1cd86d30,
|
|
0x029f3d35, 0x065e2082, 0x0b1d065b, 0x0fdc1bec,
|
|
0x3793a651, 0x3352bbe6, 0x3e119d3f, 0x3ad08088,
|
|
0x2497d08d, 0x2056cd3a, 0x2d15ebe3, 0x29d4f654,
|
|
0xc5a92679, 0xc1683bce, 0xcc2b1d17, 0xc8ea00a0,
|
|
0xd6ad50a5, 0xd26c4d12, 0xdf2f6bcb, 0xdbee767c,
|
|
0xe3a1cbc1, 0xe760d676, 0xea23f0af, 0xeee2ed18,
|
|
0xf0a5bd1d, 0xf464a0aa, 0xf9278673, 0xfde69bc4,
|
|
0x89b8fd09, 0x8d79e0be, 0x803ac667, 0x84fbdbd0,
|
|
0x9abc8bd5, 0x9e7d9662, 0x933eb0bb, 0x97ffad0c,
|
|
0xafb010b1, 0xab710d06, 0xa6322bdf, 0xa2f33668,
|
|
0xbcb4666d, 0xb8757bda, 0xb5365d03, 0xb1f740b4
|
|
};
|
|
|
|
ATSParser::PSISection::PSISection() :
|
|
mSkipBytes(0) {
|
|
}
|
|
|
|
ATSParser::PSISection::~PSISection() {
|
|
}
|
|
|
|
status_t ATSParser::PSISection::append(const void *data, size_t size) {
|
|
if (mBuffer == NULL || mBuffer->size() + size > mBuffer->capacity()) {
|
|
size_t newCapacity =
|
|
(mBuffer == NULL) ? size : mBuffer->capacity() + size;
|
|
|
|
newCapacity = (newCapacity + 1023) & ~1023;
|
|
|
|
sp<ABuffer> newBuffer = new ABuffer(newCapacity);
|
|
|
|
if (mBuffer != NULL) {
|
|
memcpy(newBuffer->data(), mBuffer->data(), mBuffer->size());
|
|
newBuffer->setRange(0, mBuffer->size());
|
|
} else {
|
|
newBuffer->setRange(0, 0);
|
|
}
|
|
|
|
mBuffer = newBuffer;
|
|
}
|
|
|
|
memcpy(mBuffer->data() + mBuffer->size(), data, size);
|
|
mBuffer->setRange(0, mBuffer->size() + size);
|
|
|
|
return OK;
|
|
}
|
|
|
|
void ATSParser::PSISection::setSkipBytes(uint8_t skip) {
|
|
mSkipBytes = skip;
|
|
}
|
|
|
|
void ATSParser::PSISection::clear() {
|
|
if (mBuffer != NULL) {
|
|
mBuffer->setRange(0, 0);
|
|
}
|
|
mSkipBytes = 0;
|
|
}
|
|
|
|
bool ATSParser::PSISection::isComplete() const {
|
|
if (mBuffer == NULL || mBuffer->size() < 3) {
|
|
return false;
|
|
}
|
|
|
|
unsigned sectionLength = U16_AT(mBuffer->data() + 1) & 0xfff;
|
|
return mBuffer->size() >= sectionLength + 3;
|
|
}
|
|
|
|
bool ATSParser::PSISection::isEmpty() const {
|
|
return mBuffer == NULL || mBuffer->size() == 0;
|
|
}
|
|
|
|
const uint8_t *ATSParser::PSISection::data() const {
|
|
return mBuffer == NULL ? NULL : mBuffer->data();
|
|
}
|
|
|
|
size_t ATSParser::PSISection::size() const {
|
|
return mBuffer == NULL ? 0 : mBuffer->size();
|
|
}
|
|
|
|
bool ATSParser::PSISection::isCRCOkay() const {
|
|
if (!isComplete()) {
|
|
return false;
|
|
}
|
|
uint8_t* data = mBuffer->data();
|
|
|
|
// Return true if section_syntax_indicator says no section follows the field section_length.
|
|
if ((data[1] & 0x80) == 0) {
|
|
return true;
|
|
}
|
|
|
|
unsigned sectionLength = U16_AT(data + 1) & 0xfff;
|
|
ALOGV("sectionLength %u, skip %u", sectionLength, mSkipBytes);
|
|
|
|
|
|
if(sectionLength < mSkipBytes) {
|
|
ALOGE("b/28333006");
|
|
android_errorWriteLog(0x534e4554, "28333006");
|
|
return false;
|
|
}
|
|
|
|
// Skip the preceding field present when payload start indicator is on.
|
|
sectionLength -= mSkipBytes;
|
|
|
|
uint32_t crc = 0xffffffff;
|
|
for(unsigned i = 0; i < sectionLength + 4 /* crc */; i++) {
|
|
uint8_t b = data[i];
|
|
int index = ((crc >> 24) ^ (b & 0xff)) & 0xff;
|
|
crc = CRC_TABLE[index] ^ (crc << 8);
|
|
}
|
|
ALOGV("crc: %08x\n", crc);
|
|
return (crc == 0);
|
|
}
|
|
|
|
// SAMPLE_AES key handling
|
|
// TODO: Merge these to their respective class after Widevine-HLS
|
|
void ATSParser::signalNewSampleAesKey(const sp<AMessage> &keyItem) {
|
|
ALOGD("signalNewSampleAesKey: %p", keyItem.get());
|
|
|
|
mSampleAesKeyItem = keyItem;
|
|
|
|
// a NULL key item will propagate to existing ElementaryStreamQueues
|
|
for (size_t i = 0; i < mPrograms.size(); ++i) {
|
|
mPrograms[i]->signalNewSampleAesKey(keyItem);
|
|
}
|
|
}
|
|
|
|
void ATSParser::Program::signalNewSampleAesKey(const sp<AMessage> &keyItem) {
|
|
ALOGD("Program::signalNewSampleAesKey: %p", keyItem.get());
|
|
|
|
mSampleAesKeyItem = keyItem;
|
|
|
|
// a NULL key item will propagate to existing ElementaryStreamQueues
|
|
for (size_t i = 0; i < mStreams.size(); ++i) {
|
|
mStreams[i]->signalNewSampleAesKey(keyItem);
|
|
}
|
|
}
|
|
|
|
void ATSParser::Stream::signalNewSampleAesKey(const sp<AMessage> &keyItem) {
|
|
ALOGD("Stream::signalNewSampleAesKey: 0x%04x size = %zu keyItem: %p",
|
|
mElementaryPID, mBuffer->size(), keyItem.get());
|
|
|
|
// a NULL key item will propagate to existing ElementaryStreamQueues
|
|
mSampleAesKeyItem = keyItem;
|
|
|
|
flush(NULL);
|
|
mQueue->signalNewSampleAesKey(keyItem);
|
|
}
|
|
|
|
} // namespace android
|