blob: 1cf97447992e3176a1ad3785da237848de52ec34 [file] [log] [blame]
/*
* 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 "ESQueue"
#include <media/stagefright/foundation/ADebug.h>
#include "ESQueue.h"
#include <media/stagefright/foundation/hexdump.h>
#include <media/stagefright/foundation/ABitReader.h>
#include <media/stagefright/foundation/ABuffer.h>
#include <media/stagefright/foundation/AMessage.h>
#include <media/stagefright/MediaErrors.h>
#include <media/stagefright/MediaDefs.h>
#include <media/stagefright/MetaData.h>
#include <media/stagefright/Utils.h>
#include <media/cas/DescramblerAPI.h>
#include <media/hardware/CryptoAPI.h>
#include "include/avc_utils.h"
#include <inttypes.h>
#include <netinet/in.h>
namespace android {
ElementaryStreamQueue::ElementaryStreamQueue(Mode mode, uint32_t flags)
: mMode(mode),
mFlags(flags),
mEOSReached(false),
mCASystemId(0),
mAUIndex(0) {
ALOGV("ElementaryStreamQueue(%p) mode %x flags %x isScrambled %d isSampleEncrypted %d",
this, mode, flags, isScrambled(), isSampleEncrypted());
// Create the decryptor anyway since we don't know the use-case unless key is provided
// Won't decrypt if key info not available (e.g., scanner/extractor just parsing ts files)
mSampleDecryptor = isSampleEncrypted() ? new HlsSampleDecryptor : NULL;
}
sp<MetaData> ElementaryStreamQueue::getFormat() {
return mFormat;
}
void ElementaryStreamQueue::clear(bool clearFormat) {
if (mBuffer != NULL) {
mBuffer->setRange(0, 0);
}
mRangeInfos.clear();
if (mScrambledBuffer != NULL) {
mScrambledBuffer->setRange(0, 0);
}
mScrambledRangeInfos.clear();
if (clearFormat) {
mFormat.clear();
}
mEOSReached = false;
}
bool ElementaryStreamQueue::isScrambled() const {
return (mFlags & kFlag_ScrambledData) != 0;
}
void ElementaryStreamQueue::setCasInfo(
int32_t systemId, const std::vector<uint8_t> &sessionId) {
mCASystemId = systemId;
mCasSessionId = sessionId;
}
// Parse AC3 header assuming the current ptr is start position of syncframe,
// update metadata only applicable, and return the payload size
static unsigned parseAC3SyncFrame(
const uint8_t *ptr, size_t size, sp<MetaData> *metaData) {
static const unsigned channelCountTable[] = {2, 1, 2, 3, 3, 4, 4, 5};
static const unsigned samplingRateTable[] = {48000, 44100, 32000};
static const unsigned frameSizeTable[19][3] = {
{ 64, 69, 96 },
{ 80, 87, 120 },
{ 96, 104, 144 },
{ 112, 121, 168 },
{ 128, 139, 192 },
{ 160, 174, 240 },
{ 192, 208, 288 },
{ 224, 243, 336 },
{ 256, 278, 384 },
{ 320, 348, 480 },
{ 384, 417, 576 },
{ 448, 487, 672 },
{ 512, 557, 768 },
{ 640, 696, 960 },
{ 768, 835, 1152 },
{ 896, 975, 1344 },
{ 1024, 1114, 1536 },
{ 1152, 1253, 1728 },
{ 1280, 1393, 1920 },
};
ABitReader bits(ptr, size);
if (bits.numBitsLeft() < 16) {
return 0;
}
if (bits.getBits(16) != 0x0B77) {
return 0;
}
if (bits.numBitsLeft() < 16 + 2 + 6 + 5 + 3 + 3) {
ALOGV("Not enough bits left for further parsing");
return 0;
}
bits.skipBits(16); // crc1
unsigned fscod = bits.getBits(2);
if (fscod == 3) {
ALOGW("Incorrect fscod in AC3 header");
return 0;
}
unsigned frmsizecod = bits.getBits(6);
if (frmsizecod > 37) {
ALOGW("Incorrect frmsizecod in AC3 header");
return 0;
}
unsigned bsid = bits.getBits(5);
if (bsid > 8) {
ALOGW("Incorrect bsid in AC3 header. Possibly E-AC-3?");
return 0;
}
unsigned bsmod __unused = bits.getBits(3);
unsigned acmod = bits.getBits(3);
unsigned cmixlev __unused = 0;
unsigned surmixlev __unused = 0;
unsigned dsurmod __unused = 0;
if ((acmod & 1) > 0 && acmod != 1) {
if (bits.numBitsLeft() < 2) {
return 0;
}
cmixlev = bits.getBits(2);
}
if ((acmod & 4) > 0) {
if (bits.numBitsLeft() < 2) {
return 0;
}
surmixlev = bits.getBits(2);
}
if (acmod == 2) {
if (bits.numBitsLeft() < 2) {
return 0;
}
dsurmod = bits.getBits(2);
}
if (bits.numBitsLeft() < 1) {
return 0;
}
unsigned lfeon = bits.getBits(1);
unsigned samplingRate = samplingRateTable[fscod];
unsigned payloadSize = frameSizeTable[frmsizecod >> 1][fscod];
if (fscod == 1) {
payloadSize += frmsizecod & 1;
}
payloadSize <<= 1; // convert from 16-bit words to bytes
unsigned channelCount = channelCountTable[acmod] + lfeon;
if (metaData != NULL) {
(*metaData)->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_AC3);
(*metaData)->setInt32(kKeyChannelCount, channelCount);
(*metaData)->setInt32(kKeySampleRate, samplingRate);
}
return payloadSize;
}
static bool IsSeeminglyValidAC3Header(const uint8_t *ptr, size_t size) {
return parseAC3SyncFrame(ptr, size, NULL) > 0;
}
static bool IsSeeminglyValidADTSHeader(
const uint8_t *ptr, size_t size, size_t *frameLength) {
if (size < 7) {
// Not enough data to verify header.
return false;
}
if (ptr[0] != 0xff || (ptr[1] >> 4) != 0x0f) {
return false;
}
unsigned layer = (ptr[1] >> 1) & 3;
if (layer != 0) {
return false;
}
unsigned ID = (ptr[1] >> 3) & 1;
unsigned profile_ObjectType = ptr[2] >> 6;
if (ID == 1 && profile_ObjectType == 3) {
// MPEG-2 profile 3 is reserved.
return false;
}
size_t frameLengthInHeader =
((ptr[3] & 3) << 11) + (ptr[4] << 3) + ((ptr[5] >> 5) & 7);
if (frameLengthInHeader > size) {
return false;
}
*frameLength = frameLengthInHeader;
return true;
}
static bool IsSeeminglyValidMPEGAudioHeader(const uint8_t *ptr, size_t size) {
if (size < 3) {
// Not enough data to verify header.
return false;
}
if (ptr[0] != 0xff || (ptr[1] >> 5) != 0x07) {
return false;
}
unsigned ID = (ptr[1] >> 3) & 3;
if (ID == 1) {
return false; // reserved
}
unsigned layer = (ptr[1] >> 1) & 3;
if (layer == 0) {
return false; // reserved
}
unsigned bitrateIndex = (ptr[2] >> 4);
if (bitrateIndex == 0x0f) {
return false; // reserved
}
unsigned samplingRateIndex = (ptr[2] >> 2) & 3;
if (samplingRateIndex == 3) {
return false; // reserved
}
return true;
}
status_t ElementaryStreamQueue::appendData(
const void *data, size_t size, int64_t timeUs,
int32_t payloadOffset, uint32_t pesScramblingControl) {
if (mEOSReached) {
ALOGE("appending data after EOS");
return ERROR_MALFORMED;
}
if (mBuffer == NULL || mBuffer->size() == 0) {
switch (mMode) {
case H264:
case MPEG_VIDEO:
{
#if 0
if (size < 4 || memcmp("\x00\x00\x00\x01", data, 4)) {
return ERROR_MALFORMED;
}
#else
uint8_t *ptr = (uint8_t *)data;
ssize_t startOffset = -1;
for (size_t i = 0; i + 2 < size; ++i) {
if (!memcmp("\x00\x00\x01", &ptr[i], 3)) {
startOffset = i;
break;
}
}
if (startOffset < 0) {
return ERROR_MALFORMED;
}
if (mFormat == NULL && startOffset > 0) {
ALOGI("found something resembling an H.264/MPEG syncword "
"at offset %zd",
startOffset);
}
data = &ptr[startOffset];
size -= startOffset;
#endif
break;
}
case MPEG4_VIDEO:
{
#if 0
if (size < 3 || memcmp("\x00\x00\x01", data, 3)) {
return ERROR_MALFORMED;
}
#else
uint8_t *ptr = (uint8_t *)data;
ssize_t startOffset = -1;
for (size_t i = 0; i + 2 < size; ++i) {
if (!memcmp("\x00\x00\x01", &ptr[i], 3)) {
startOffset = i;
break;
}
}
if (startOffset < 0) {
return ERROR_MALFORMED;
}
if (startOffset > 0) {
ALOGI("found something resembling an H.264/MPEG syncword "
"at offset %zd",
startOffset);
}
data = &ptr[startOffset];
size -= startOffset;
#endif
break;
}
case AAC:
{
uint8_t *ptr = (uint8_t *)data;
#if 0
if (size < 2 || ptr[0] != 0xff || (ptr[1] >> 4) != 0x0f) {
return ERROR_MALFORMED;
}
#else
ssize_t startOffset = -1;
size_t frameLength;
for (size_t i = 0; i < size; ++i) {
if (IsSeeminglyValidADTSHeader(
&ptr[i], size - i, &frameLength)) {
startOffset = i;
break;
}
}
if (startOffset < 0) {
return ERROR_MALFORMED;
}
if (startOffset > 0) {
ALOGI("found something resembling an AAC syncword at "
"offset %zd",
startOffset);
}
if (frameLength != size - startOffset) {
ALOGV("First ADTS AAC frame length is %zd bytes, "
"while the buffer size is %zd bytes.",
frameLength, size - startOffset);
}
data = &ptr[startOffset];
size -= startOffset;
#endif
break;
}
case AC3:
{
uint8_t *ptr = (uint8_t *)data;
ssize_t startOffset = -1;
for (size_t i = 0; i < size; ++i) {
if (IsSeeminglyValidAC3Header(&ptr[i], size - i)) {
startOffset = i;
break;
}
}
if (startOffset < 0) {
return ERROR_MALFORMED;
}
if (startOffset > 0) {
ALOGI("found something resembling an AC3 syncword at "
"offset %zd",
startOffset);
}
data = &ptr[startOffset];
size -= startOffset;
break;
}
case MPEG_AUDIO:
{
uint8_t *ptr = (uint8_t *)data;
ssize_t startOffset = -1;
for (size_t i = 0; i < size; ++i) {
if (IsSeeminglyValidMPEGAudioHeader(&ptr[i], size - i)) {
startOffset = i;
break;
}
}
if (startOffset < 0) {
return ERROR_MALFORMED;
}
if (startOffset > 0) {
ALOGI("found something resembling an MPEG audio "
"syncword at offset %zd",
startOffset);
}
data = &ptr[startOffset];
size -= startOffset;
break;
}
case PCM_AUDIO:
case METADATA:
{
break;
}
default:
ALOGE("Unknown mode: %d", mMode);
return ERROR_MALFORMED;
}
}
size_t neededSize = (mBuffer == NULL ? 0 : mBuffer->size()) + size;
if (mBuffer == NULL || neededSize > mBuffer->capacity()) {
neededSize = (neededSize + 65535) & ~65535;
ALOGV("resizing buffer to size %zu", neededSize);
sp<ABuffer> buffer = new ABuffer(neededSize);
if (mBuffer != NULL) {
memcpy(buffer->data(), mBuffer->data(), mBuffer->size());
buffer->setRange(0, mBuffer->size());
} else {
buffer->setRange(0, 0);
}
mBuffer = buffer;
}
memcpy(mBuffer->data() + mBuffer->size(), data, size);
mBuffer->setRange(0, mBuffer->size() + size);
RangeInfo info;
info.mLength = size;
info.mTimestampUs = timeUs;
info.mPesOffset = payloadOffset;
info.mPesScramblingControl = pesScramblingControl;
mRangeInfos.push_back(info);
#if 0
if (mMode == AAC) {
ALOGI("size = %zu, timeUs = %.2f secs", size, timeUs / 1E6);
hexdump(data, size);
}
#endif
return OK;
}
void ElementaryStreamQueue::appendScrambledData(
const void *data, size_t size,
int32_t keyId, bool isSync,
sp<ABuffer> clearSizes, sp<ABuffer> encSizes) {
if (!isScrambled()) {
return;
}
size_t neededSize = (mScrambledBuffer == NULL ? 0 : mScrambledBuffer->size()) + size;
if (mScrambledBuffer == NULL || neededSize > mScrambledBuffer->capacity()) {
neededSize = (neededSize + 65535) & ~65535;
ALOGI("resizing scrambled buffer to size %zu", neededSize);
sp<ABuffer> buffer = new ABuffer(neededSize);
if (mScrambledBuffer != NULL) {
memcpy(buffer->data(), mScrambledBuffer->data(), mScrambledBuffer->size());
buffer->setRange(0, mScrambledBuffer->size());
} else {
buffer->setRange(0, 0);
}
mScrambledBuffer = buffer;
}
memcpy(mScrambledBuffer->data() + mScrambledBuffer->size(), data, size);
mScrambledBuffer->setRange(0, mScrambledBuffer->size() + size);
ScrambledRangeInfo scrambledInfo;
scrambledInfo.mLength = size;
scrambledInfo.mKeyId = keyId;
scrambledInfo.mIsSync = isSync;
scrambledInfo.mClearSizes = clearSizes;
scrambledInfo.mEncSizes = encSizes;
ALOGV("[stream %d] appending scrambled range: size=%zu", mMode, size);
mScrambledRangeInfos.push_back(scrambledInfo);
}
sp<ABuffer> ElementaryStreamQueue::dequeueScrambledAccessUnit() {
size_t nextScan = mBuffer->size();
mBuffer->setRange(0, 0);
int32_t pesOffset = 0, pesScramblingControl = 0;
int64_t timeUs = fetchTimestamp(nextScan, &pesOffset, &pesScramblingControl);
if (timeUs < 0ll) {
ALOGE("Negative timeUs");
return NULL;
}
// return scrambled unit
int32_t keyId = pesScramblingControl, isSync = 0, scrambledLength = 0;
sp<ABuffer> clearSizes, encSizes;
while (mScrambledRangeInfos.size() > mRangeInfos.size()) {
auto it = mScrambledRangeInfos.begin();
ALOGV("[stream %d] fetching scrambled range: size=%zu", mMode, it->mLength);
if (scrambledLength > 0) {
// This shouldn't happen since we always dequeue the entire PES.
ALOGW("Discarding srambled length %d", scrambledLength);
}
scrambledLength = it->mLength;
// TODO: handle key id change, use first non-zero keyId for now
if (keyId == 0) {
keyId = it->mKeyId;
}
clearSizes = it->mClearSizes;
encSizes = it->mEncSizes;
isSync = it->mIsSync;
mScrambledRangeInfos.erase(it);
}
if (scrambledLength == 0) {
ALOGE("[stream %d] empty scrambled unit!", mMode);
return NULL;
}
// skip the PES header, and copy the rest into scrambled access unit
sp<ABuffer> scrambledAccessUnit = ABuffer::CreateAsCopy(
mScrambledBuffer->data() + pesOffset,
scrambledLength - pesOffset);
// fix up first sample size after skipping the PES header
if (pesOffset > 0) {
int32_t &firstClearSize = *(int32_t*)clearSizes->data();
int32_t &firstEncSize = *(int32_t*)encSizes->data();
// Cut away the PES header
if (firstClearSize >= pesOffset) {
// This is for TS-level scrambling, we descrambled the first
// (or it was clear to begin with)
firstClearSize -= pesOffset;
} else if (firstEncSize >= pesOffset) {
// This can only be PES-level scrambling
firstEncSize -= pesOffset;
}
}
scrambledAccessUnit->meta()->setInt64("timeUs", timeUs);
if (isSync) {
scrambledAccessUnit->meta()->setInt32("isSync", 1);
}
// fill in CryptoInfo fields for AnotherPacketSource::read()
// MediaCas doesn't use cryptoMode, but set to non-zero value here.
scrambledAccessUnit->meta()->setInt32(
"cryptoMode", CryptoPlugin::kMode_AES_CTR);
scrambledAccessUnit->meta()->setInt32("cryptoKey", keyId);
scrambledAccessUnit->meta()->setBuffer("clearBytes", clearSizes);
scrambledAccessUnit->meta()->setBuffer("encBytes", encSizes);
memmove(mScrambledBuffer->data(),
mScrambledBuffer->data() + scrambledLength,
mScrambledBuffer->size() - scrambledLength);
mScrambledBuffer->setRange(0, mScrambledBuffer->size() - scrambledLength);
ALOGV("[stream %d] dequeued scrambled AU: timeUs=%lld, size=%zu",
mMode, (long long)timeUs, scrambledAccessUnit->size());
return scrambledAccessUnit;
}
sp<ABuffer> ElementaryStreamQueue::dequeueAccessUnit() {
if ((mFlags & kFlag_AlignedData) && mMode == H264 && !isScrambled()) {
if (mRangeInfos.empty()) {
return NULL;
}
RangeInfo info = *mRangeInfos.begin();
mRangeInfos.erase(mRangeInfos.begin());
sp<ABuffer> accessUnit = new ABuffer(info.mLength);
memcpy(accessUnit->data(), mBuffer->data(), info.mLength);
accessUnit->meta()->setInt64("timeUs", info.mTimestampUs);
memmove(mBuffer->data(),
mBuffer->data() + info.mLength,
mBuffer->size() - info.mLength);
mBuffer->setRange(0, mBuffer->size() - info.mLength);
if (mFormat == NULL) {
mFormat = MakeAVCCodecSpecificData(accessUnit);
}
return accessUnit;
}
switch (mMode) {
case H264:
return dequeueAccessUnitH264();
case AAC:
return dequeueAccessUnitAAC();
case AC3:
return dequeueAccessUnitAC3();
case MPEG_VIDEO:
return dequeueAccessUnitMPEGVideo();
case MPEG4_VIDEO:
return dequeueAccessUnitMPEG4Video();
case PCM_AUDIO:
return dequeueAccessUnitPCMAudio();
case METADATA:
return dequeueAccessUnitMetadata();
default:
if (mMode != MPEG_AUDIO) {
ALOGE("Unknown mode");
return NULL;
}
return dequeueAccessUnitMPEGAudio();
}
}
sp<ABuffer> ElementaryStreamQueue::dequeueAccessUnitAC3() {
unsigned syncStartPos = 0; // in bytes
unsigned payloadSize = 0;
sp<MetaData> format = new MetaData;
ALOGV("dequeueAccessUnit_AC3[%d]: mBuffer %p(%zu)", mAUIndex, mBuffer->data(), mBuffer->size());
while (true) {
if (syncStartPos + 2 >= mBuffer->size()) {
return NULL;
}
payloadSize = parseAC3SyncFrame(
mBuffer->data() + syncStartPos,
mBuffer->size() - syncStartPos,
&format);
if (payloadSize > 0) {
break;
}
ALOGV("dequeueAccessUnit_AC3[%d]: syncStartPos %u payloadSize %u",
mAUIndex, syncStartPos, payloadSize);
++syncStartPos;
}
if (mBuffer->size() < syncStartPos + payloadSize) {
ALOGV("Not enough buffer size for AC3");
return NULL;
}
if (mFormat == NULL) {
mFormat = format;
}
int64_t timeUs = fetchTimestamp(syncStartPos + payloadSize);
if (timeUs < 0ll) {
ALOGE("negative timeUs");
return NULL;
}
// Not decrypting if key info not available (e.g., scanner/extractor parsing ts files)
if (mSampleDecryptor != NULL) {
mSampleDecryptor->processAC3(mBuffer->data() + syncStartPos, payloadSize);
}
mAUIndex++;
sp<ABuffer> accessUnit = new ABuffer(syncStartPos + payloadSize);
memcpy(accessUnit->data(), mBuffer->data(), syncStartPos + payloadSize);
accessUnit->meta()->setInt64("timeUs", timeUs);
accessUnit->meta()->setInt32("isSync", 1);
memmove(
mBuffer->data(),
mBuffer->data() + syncStartPos + payloadSize,
mBuffer->size() - syncStartPos - payloadSize);
mBuffer->setRange(0, mBuffer->size() - syncStartPos - payloadSize);
return accessUnit;
}
sp<ABuffer> ElementaryStreamQueue::dequeueAccessUnitPCMAudio() {
if (mBuffer->size() < 4) {
return NULL;
}
ABitReader bits(mBuffer->data(), 4);
if (bits.getBits(8) != 0xa0) {
ALOGE("Unexpected bit values");
return NULL;
}
unsigned numAUs = bits.getBits(8);
bits.skipBits(8);
unsigned quantization_word_length __unused = bits.getBits(2);
unsigned audio_sampling_frequency = bits.getBits(3);
unsigned num_channels = bits.getBits(3);
if (audio_sampling_frequency != 2) {
ALOGE("Wrong sampling freq");
return NULL;
}
if (num_channels != 1u) {
ALOGE("Wrong channel #");
return NULL;
}
if (mFormat == NULL) {
mFormat = new MetaData;
mFormat->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_RAW);
mFormat->setInt32(kKeyChannelCount, 2);
mFormat->setInt32(kKeySampleRate, 48000);
mFormat->setInt32(kKeyPcmEncoding, kAudioEncodingPcm16bit);
}
static const size_t kFramesPerAU = 80;
size_t frameSize = 2 /* numChannels */ * sizeof(int16_t);
size_t payloadSize = numAUs * frameSize * kFramesPerAU;
if (mBuffer->size() < 4 + payloadSize) {
return NULL;
}
sp<ABuffer> accessUnit = new ABuffer(payloadSize);
memcpy(accessUnit->data(), mBuffer->data() + 4, payloadSize);
int64_t timeUs = fetchTimestamp(payloadSize + 4);
if (timeUs < 0ll) {
ALOGE("Negative timeUs");
return NULL;
}
accessUnit->meta()->setInt64("timeUs", timeUs);
accessUnit->meta()->setInt32("isSync", 1);
int16_t *ptr = (int16_t *)accessUnit->data();
for (size_t i = 0; i < payloadSize / sizeof(int16_t); ++i) {
ptr[i] = ntohs(ptr[i]);
}
memmove(
mBuffer->data(),
mBuffer->data() + 4 + payloadSize,
mBuffer->size() - 4 - payloadSize);
mBuffer->setRange(0, mBuffer->size() - 4 - payloadSize);
return accessUnit;
}
sp<ABuffer> ElementaryStreamQueue::dequeueAccessUnitAAC() {
if (mBuffer->size() == 0) {
return NULL;
}
if (mRangeInfos.empty()) {
return NULL;
}
const RangeInfo &info = *mRangeInfos.begin();
if (mBuffer->size() < info.mLength) {
return NULL;
}
if (info.mTimestampUs < 0ll) {
ALOGE("Negative info.mTimestampUs");
return NULL;
}
ALOGV("dequeueAccessUnit_AAC[%d]: mBuffer %zu info.mLength %zu",
mAUIndex, mBuffer->size(), info.mLength);
struct ADTSPosition {
size_t offset;
size_t headerSize;
size_t length;
};
Vector<ADTSPosition> frames;
// The idea here is consume all AAC frames starting at offsets before
// info.mLength so we can assign a meaningful timestamp without
// having to interpolate.
// The final AAC frame may well extend into the next RangeInfo but
// that's ok.
size_t offset = 0;
while (offset < info.mLength) {
if (offset + 7 > mBuffer->size()) {
return NULL;
}
ABitReader bits(mBuffer->data() + offset, mBuffer->size() - offset);
// adts_fixed_header
if (bits.getBits(12) != 0xfffu) {
ALOGE("Wrong atds_fixed_header");
return NULL;
}
bits.skipBits(3); // ID, layer
bool protection_absent = bits.getBits(1) != 0;
if (mFormat == NULL) {
unsigned profile = bits.getBits(2);
if (profile == 3u) {
ALOGE("profile should not be 3");
return NULL;
}
unsigned sampling_freq_index = bits.getBits(4);
bits.getBits(1); // private_bit
unsigned channel_configuration = bits.getBits(3);
if (channel_configuration == 0u) {
ALOGE("channel_config should not be 0");
return NULL;
}
bits.skipBits(2); // original_copy, home
mFormat = MakeAACCodecSpecificData(
profile, sampling_freq_index, channel_configuration);
mFormat->setInt32(kKeyIsADTS, true);
int32_t sampleRate;
int32_t numChannels;
if (!mFormat->findInt32(kKeySampleRate, &sampleRate)) {
ALOGE("SampleRate not found");
return NULL;
}
if (!mFormat->findInt32(kKeyChannelCount, &numChannels)) {
ALOGE("ChannelCount not found");
return NULL;
}
ALOGI("found AAC codec config (%d Hz, %d channels)",
sampleRate, numChannels);
} else {
// profile_ObjectType, sampling_frequency_index, private_bits,
// channel_configuration, original_copy, home
bits.skipBits(12);
}
// adts_variable_header
// copyright_identification_bit, copyright_identification_start
bits.skipBits(2);
unsigned aac_frame_length = bits.getBits(13);
if (aac_frame_length == 0){
ALOGE("b/62673179, Invalid AAC frame length!");
android_errorWriteLog(0x534e4554, "62673179");
return NULL;
}
bits.skipBits(11); // adts_buffer_fullness
unsigned number_of_raw_data_blocks_in_frame = bits.getBits(2);
if (number_of_raw_data_blocks_in_frame != 0) {
// To be implemented.
ALOGE("Should not reach here.");
return NULL;
}
if (offset + aac_frame_length > mBuffer->size()) {
return NULL;
}
size_t headerSize = protection_absent ? 7 : 9;
// tracking the frame positions first then decrypt only if an accessUnit to be generated
if (mSampleDecryptor != NULL) {
ADTSPosition frame = {
.offset = offset,
.headerSize = headerSize,
.length = aac_frame_length
};
frames.push(frame);
}
offset += aac_frame_length;
}
// Decrypting only if the loop didn't exit early and an accessUnit is about to be generated
// Not decrypting if key info not available (e.g., scanner/extractor parsing ts files)
if (mSampleDecryptor != NULL) {
for (size_t frameId = 0; frameId < frames.size(); frameId++) {
const ADTSPosition &frame = frames.itemAt(frameId);
mSampleDecryptor->processAAC(frame.headerSize,
mBuffer->data() + frame.offset, frame.length);
// ALOGV("dequeueAccessUnitAAC[%zu]: while offset %zu headerSize %zu frame_len %zu",
// frameId, frame.offset, frame.headerSize, frame.length);
}
}
mAUIndex++;
int64_t timeUs = fetchTimestamp(offset);
sp<ABuffer> accessUnit = new ABuffer(offset);
memcpy(accessUnit->data(), mBuffer->data(), offset);
memmove(mBuffer->data(), mBuffer->data() + offset,
mBuffer->size() - offset);
mBuffer->setRange(0, mBuffer->size() - offset);
accessUnit->meta()->setInt64("timeUs", timeUs);
accessUnit->meta()->setInt32("isSync", 1);
return accessUnit;
}
int64_t ElementaryStreamQueue::fetchTimestamp(
size_t size, int32_t *pesOffset, int32_t *pesScramblingControl) {
int64_t timeUs = -1;
bool first = true;
while (size > 0) {
if (mRangeInfos.empty()) {
return timeUs;
}
RangeInfo *info = &*mRangeInfos.begin();
if (first) {
timeUs = info->mTimestampUs;
if (pesOffset != NULL) {
*pesOffset = info->mPesOffset;
}
if (pesScramblingControl != NULL) {
*pesScramblingControl = info->mPesScramblingControl;
}
first = false;
}
if (info->mLength > size) {
info->mLength -= size;
size = 0;
} else {
size -= info->mLength;
mRangeInfos.erase(mRangeInfos.begin());
info = NULL;
}
}
if (timeUs == 0ll) {
ALOGV("Returning 0 timestamp");
}
return timeUs;
}
sp<ABuffer> ElementaryStreamQueue::dequeueAccessUnitH264() {
if (isScrambled()) {
if (mBuffer == NULL || mBuffer->size() == 0) {
return NULL;
}
if (mFormat == NULL) {
mFormat = MakeAVCCodecSpecificData(mBuffer);
if (mFormat == NULL) {
ALOGI("Creating dummy AVC format for scrambled content");
mFormat = new MetaData;
mFormat->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_AVC);
mFormat->setInt32(kKeyWidth, 1280);
mFormat->setInt32(kKeyHeight, 720);
}
// for MediaExtractor.CasInfo
mFormat->setInt32(kKeyCASystemID, mCASystemId);
mFormat->setData(kKeyCASessionID, 0,
mCasSessionId.data(), mCasSessionId.size());
}
return dequeueScrambledAccessUnit();
}
const uint8_t *data = mBuffer->data();
size_t size = mBuffer->size();
Vector<NALPosition> nals;
size_t totalSize = 0;
size_t seiCount = 0;
status_t err;
const uint8_t *nalStart;
size_t nalSize;
bool foundSlice = false;
bool foundIDR = false;
ALOGV("dequeueAccessUnit_H264[%d] %p/%zu", mAUIndex, data, size);
while ((err = getNextNALUnit(&data, &size, &nalStart, &nalSize)) == OK) {
if (nalSize == 0) continue;
unsigned nalType = nalStart[0] & 0x1f;
bool flush = false;
if (nalType == 1 || nalType == 5) {
if (nalType == 5) {
foundIDR = true;
}
if (foundSlice) {
//TODO: Shouldn't this have been called with nalSize-1?
ABitReader br(nalStart + 1, nalSize);
unsigned first_mb_in_slice = parseUE(&br);
if (first_mb_in_slice == 0) {
// This slice starts a new frame.
flush = true;
}
}
foundSlice = true;
} else if ((nalType == 9 || nalType == 7) && foundSlice) {
// Access unit delimiter and SPS will be associated with the
// next frame.
flush = true;
} else if (nalType == 6 && nalSize > 0) {
// found non-zero sized SEI
++seiCount;
}
if (flush) {
// The access unit will contain all nal units up to, but excluding
// the current one, separated by 0x00 0x00 0x00 0x01 startcodes.
size_t auSize = 4 * nals.size() + totalSize;
sp<ABuffer> accessUnit = new ABuffer(auSize);
sp<ABuffer> sei;
if (seiCount > 0) {
sei = new ABuffer(seiCount * sizeof(NALPosition));
accessUnit->meta()->setBuffer("sei", sei);
}
#if !LOG_NDEBUG
AString out;
#endif
size_t dstOffset = 0;
size_t seiIndex = 0;
size_t shrunkBytes = 0;
for (size_t i = 0; i < nals.size(); ++i) {
const NALPosition &pos = nals.itemAt(i);
unsigned nalType = mBuffer->data()[pos.nalOffset] & 0x1f;
if (nalType == 6 && pos.nalSize > 0) {
if (seiIndex >= sei->size() / sizeof(NALPosition)) {
ALOGE("Wrong seiIndex");
return NULL;
}
NALPosition &seiPos = ((NALPosition *)sei->data())[seiIndex++];
seiPos.nalOffset = dstOffset + 4;
seiPos.nalSize = pos.nalSize;
}
#if !LOG_NDEBUG
char tmp[128];
sprintf(tmp, "0x%02x", nalType);
if (i > 0) {
out.append(", ");
}
out.append(tmp);
#endif
memcpy(accessUnit->data() + dstOffset, "\x00\x00\x00\x01", 4);
if (mSampleDecryptor != NULL && (nalType == 1 || nalType == 5)) {
uint8_t *nalData = mBuffer->data() + pos.nalOffset;
size_t newSize = mSampleDecryptor->processNal(nalData, pos.nalSize);
// Note: the data can shrink due to unescaping
memcpy(accessUnit->data() + dstOffset + 4,
nalData,
newSize);
dstOffset += newSize + 4;
size_t thisShrunkBytes = pos.nalSize - newSize;
//ALOGV("dequeueAccessUnitH264[%d]: nalType: %d -> %zu (%zu)",
// nalType, (int)pos.nalSize, newSize, thisShrunkBytes);
shrunkBytes += thisShrunkBytes;
}
else {
memcpy(accessUnit->data() + dstOffset + 4,
mBuffer->data() + pos.nalOffset,
pos.nalSize);
dstOffset += pos.nalSize + 4;
//ALOGV("dequeueAccessUnitH264 [%d] %d @%d",
// nalType, (int)pos.nalSize, (int)pos.nalOffset);
}
}
#if !LOG_NDEBUG
ALOGV("accessUnit contains nal types %s", out.c_str());
#endif
const NALPosition &pos = nals.itemAt(nals.size() - 1);
size_t nextScan = pos.nalOffset + pos.nalSize;
memmove(mBuffer->data(),
mBuffer->data() + nextScan,
mBuffer->size() - nextScan);
mBuffer->setRange(0, mBuffer->size() - nextScan);
int64_t timeUs = fetchTimestamp(nextScan);
if (timeUs < 0ll) {
ALOGE("Negative timeUs");
return NULL;
}
accessUnit->meta()->setInt64("timeUs", timeUs);
if (foundIDR) {
accessUnit->meta()->setInt32("isSync", 1);
}
if (mFormat == NULL) {
mFormat = MakeAVCCodecSpecificData(accessUnit);
}
if (mSampleDecryptor != NULL && shrunkBytes > 0) {
size_t adjustedSize = accessUnit->size() - shrunkBytes;
ALOGV("dequeueAccessUnitH264[%d]: AU size adjusted %zu -> %zu",
mAUIndex, accessUnit->size(), adjustedSize);
accessUnit->setRange(0, adjustedSize);
}
ALOGV("dequeueAccessUnitH264[%d]: AU %p(%zu) dstOffset:%zu, nals:%zu, totalSize:%zu ",
mAUIndex, accessUnit->data(), accessUnit->size(),
dstOffset, nals.size(), totalSize);
mAUIndex++;
return accessUnit;
}
NALPosition pos;
pos.nalOffset = nalStart - mBuffer->data();
pos.nalSize = nalSize;
nals.push(pos);
totalSize += nalSize;
}
if (err != (status_t)-EAGAIN) {
ALOGE("Unexpeted err");
return NULL;
}
return NULL;
}
sp<ABuffer> ElementaryStreamQueue::dequeueAccessUnitMPEGAudio() {
const uint8_t *data = mBuffer->data();
size_t size = mBuffer->size();
if (size < 4) {
return NULL;
}
uint32_t header = U32_AT(data);
size_t frameSize;
int samplingRate, numChannels, bitrate, numSamples;
if (!GetMPEGAudioFrameSize(
header, &frameSize, &samplingRate, &numChannels,
&bitrate, &numSamples)) {
ALOGE("Failed to get audio frame size");
return NULL;
}
if (size < frameSize) {
return NULL;
}
unsigned layer = 4 - ((header >> 17) & 3);
sp<ABuffer> accessUnit = new ABuffer(frameSize);
memcpy(accessUnit->data(), data, frameSize);
memmove(mBuffer->data(),
mBuffer->data() + frameSize,
mBuffer->size() - frameSize);
mBuffer->setRange(0, mBuffer->size() - frameSize);
int64_t timeUs = fetchTimestamp(frameSize);
if (timeUs < 0ll) {
ALOGE("Negative timeUs");
return NULL;
}
accessUnit->meta()->setInt64("timeUs", timeUs);
accessUnit->meta()->setInt32("isSync", 1);
if (mFormat == NULL) {
mFormat = new MetaData;
switch (layer) {
case 1:
mFormat->setCString(
kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_MPEG_LAYER_I);
break;
case 2:
mFormat->setCString(
kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_MPEG_LAYER_II);
break;
case 3:
mFormat->setCString(
kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_MPEG);
break;
default:
return NULL;
}
mFormat->setInt32(kKeySampleRate, samplingRate);
mFormat->setInt32(kKeyChannelCount, numChannels);
}
return accessUnit;
}
static void EncodeSize14(uint8_t **_ptr, size_t size) {
if (size > 0x3fff) {
ALOGE("Wrong size");
return;
}
uint8_t *ptr = *_ptr;
*ptr++ = 0x80 | (size >> 7);
*ptr++ = size & 0x7f;
*_ptr = ptr;
}
static sp<ABuffer> MakeMPEGVideoESDS(const sp<ABuffer> &csd) {
sp<ABuffer> esds = new ABuffer(csd->size() + 25);
uint8_t *ptr = esds->data();
*ptr++ = 0x03;
EncodeSize14(&ptr, 22 + csd->size());
*ptr++ = 0x00; // ES_ID
*ptr++ = 0x00;
*ptr++ = 0x00; // streamDependenceFlag, URL_Flag, OCRstreamFlag
*ptr++ = 0x04;
EncodeSize14(&ptr, 16 + csd->size());
*ptr++ = 0x40; // Audio ISO/IEC 14496-3
for (size_t i = 0; i < 12; ++i) {
*ptr++ = 0x00;
}
*ptr++ = 0x05;
EncodeSize14(&ptr, csd->size());
memcpy(ptr, csd->data(), csd->size());
return esds;
}
sp<ABuffer> ElementaryStreamQueue::dequeueAccessUnitMPEGVideo() {
if (isScrambled()) {
if (mBuffer == NULL || mBuffer->size() == 0) {
return NULL;
}
if (mFormat == NULL) {
ALOGI("Creating dummy MPEG format for scrambled content");
mFormat = new MetaData;
mFormat->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_MPEG2);
mFormat->setInt32(kKeyWidth, 1280);
mFormat->setInt32(kKeyHeight, 720);
// for MediaExtractor.CasInfo
mFormat->setInt32(kKeyCASystemID, mCASystemId);
mFormat->setData(kKeyCASessionID, 0,
mCasSessionId.data(), mCasSessionId.size());
}
return dequeueScrambledAccessUnit();
}
const uint8_t *data = mBuffer->data();
size_t size = mBuffer->size();
Vector<size_t> userDataPositions;
bool sawPictureStart = false;
int pprevStartCode = -1;
int prevStartCode = -1;
int currentStartCode = -1;
bool gopFound = false;
bool isClosedGop = false;
bool brokenLink = false;
size_t offset = 0;
while (offset + 3 < size) {
if (memcmp(&data[offset], "\x00\x00\x01", 3)) {
++offset;
continue;
}
pprevStartCode = prevStartCode;
prevStartCode = currentStartCode;
currentStartCode = data[offset + 3];
if (currentStartCode == 0xb3 && mFormat == NULL) {
memmove(mBuffer->data(), mBuffer->data() + offset, size - offset);
size -= offset;
(void)fetchTimestamp(offset);
offset = 0;
mBuffer->setRange(0, size);
}
if ((prevStartCode == 0xb3 && currentStartCode != 0xb5)
|| (pprevStartCode == 0xb3 && prevStartCode == 0xb5)) {
// seqHeader without/with extension
if (mFormat == NULL) {
if (size < 7u) {
ALOGE("Size too small");
return NULL;
}
unsigned width =
(data[4] << 4) | data[5] >> 4;
unsigned height =
((data[5] & 0x0f) << 8) | data[6];
mFormat = new MetaData;
mFormat->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_MPEG2);
mFormat->setInt32(kKeyWidth, width);
mFormat->setInt32(kKeyHeight, height);
ALOGI("found MPEG2 video codec config (%d x %d)", width, height);
sp<ABuffer> csd = new ABuffer(offset);
memcpy(csd->data(), data, offset);
memmove(mBuffer->data(),
mBuffer->data() + offset,
mBuffer->size() - offset);
mBuffer->setRange(0, mBuffer->size() - offset);
size -= offset;
(void)fetchTimestamp(offset);
offset = 0;
// hexdump(csd->data(), csd->size());
sp<ABuffer> esds = MakeMPEGVideoESDS(csd);
mFormat->setData(
kKeyESDS, kTypeESDS, esds->data(), esds->size());
return NULL;
}
}
if (mFormat != NULL && currentStartCode == 0xb8) {
// GOP layer
if (offset + 7 >= size) {
ALOGE("Size too small");
return NULL;
}
gopFound = true;
isClosedGop = (data[offset + 7] & 0x40) != 0;
brokenLink = (data[offset + 7] & 0x20) != 0;
}
if (mFormat != NULL && currentStartCode == 0xb2) {
userDataPositions.add(offset);
}
if (mFormat != NULL && currentStartCode == 0x00) {
// Picture start
if (!sawPictureStart) {
sawPictureStart = true;
} else {
sp<ABuffer> accessUnit = new ABuffer(offset);
memcpy(accessUnit->data(), data, offset);
memmove(mBuffer->data(),
mBuffer->data() + offset,
mBuffer->size() - offset);
mBuffer->setRange(0, mBuffer->size() - offset);
int64_t timeUs = fetchTimestamp(offset);
if (timeUs < 0ll) {
ALOGE("Negative timeUs");
return NULL;
}
offset = 0;
accessUnit->meta()->setInt64("timeUs", timeUs);
if (gopFound && (!brokenLink || isClosedGop)) {
accessUnit->meta()->setInt32("isSync", 1);
}
ALOGV("returning MPEG video access unit at time %" PRId64 " us",
timeUs);
// hexdump(accessUnit->data(), accessUnit->size());
if (userDataPositions.size() > 0) {
sp<ABuffer> mpegUserData =
new ABuffer(userDataPositions.size() * sizeof(size_t));
if (mpegUserData != NULL && mpegUserData->data() != NULL) {
for (size_t i = 0; i < userDataPositions.size(); ++i) {
memcpy(
mpegUserData->data() + i * sizeof(size_t),
&userDataPositions[i], sizeof(size_t));
}
accessUnit->meta()->setBuffer("mpegUserData", mpegUserData);
}
}
return accessUnit;
}
}
++offset;
}
return NULL;
}
static ssize_t getNextChunkSize(
const uint8_t *data, size_t size) {
static const char kStartCode[] = "\x00\x00\x01";
if (size < 3) {
return -EAGAIN;
}
if (memcmp(kStartCode, data, 3)) {
return -EAGAIN;
}
size_t offset = 3;
while (offset + 2 < size) {
if (!memcmp(&data[offset], kStartCode, 3)) {
return offset;
}
++offset;
}
return -EAGAIN;
}
sp<ABuffer> ElementaryStreamQueue::dequeueAccessUnitMPEG4Video() {
uint8_t *data = mBuffer->data();
size_t size = mBuffer->size();
enum {
SKIP_TO_VISUAL_OBJECT_SEQ_START,
EXPECT_VISUAL_OBJECT_START,
EXPECT_VO_START,
EXPECT_VOL_START,
WAIT_FOR_VOP_START,
SKIP_TO_VOP_START,
} state;
if (mFormat == NULL) {
state = SKIP_TO_VISUAL_OBJECT_SEQ_START;
} else {
state = SKIP_TO_VOP_START;
}
int32_t width = -1, height = -1;
size_t offset = 0;
ssize_t chunkSize;
while ((chunkSize = getNextChunkSize(
&data[offset], size - offset)) > 0) {
bool discard = false;
unsigned chunkType = data[offset + 3];
switch (state) {
case SKIP_TO_VISUAL_OBJECT_SEQ_START:
{
if (chunkType == 0xb0) {
// Discard anything before this marker.
state = EXPECT_VISUAL_OBJECT_START;
} else {
discard = true;
}
break;
}
case EXPECT_VISUAL_OBJECT_START:
{
if (chunkType != 0xb5) {
ALOGE("Unexpected chunkType");
return NULL;
}
state = EXPECT_VO_START;
break;
}
case EXPECT_VO_START:
{
if (chunkType > 0x1f) {
ALOGE("Unexpected chunkType");
return NULL;
}
state = EXPECT_VOL_START;
break;
}
case EXPECT_VOL_START:
{
if ((chunkType & 0xf0) != 0x20) {
ALOGE("Wrong chunkType");
return NULL;
}
if (!ExtractDimensionsFromVOLHeader(
&data[offset], chunkSize,
&width, &height)) {
ALOGE("Failed to get dimension");
return NULL;
}
state = WAIT_FOR_VOP_START;
break;
}
case WAIT_FOR_VOP_START:
{
if (chunkType == 0xb3 || chunkType == 0xb6) {
// group of VOP or VOP start.
mFormat = new MetaData;
mFormat->setCString(
kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_MPEG4);
mFormat->setInt32(kKeyWidth, width);
mFormat->setInt32(kKeyHeight, height);
ALOGI("found MPEG4 video codec config (%d x %d)",
width, height);
sp<ABuffer> csd = new ABuffer(offset);
memcpy(csd->data(), data, offset);
// hexdump(csd->data(), csd->size());
sp<ABuffer> esds = MakeMPEGVideoESDS(csd);
mFormat->setData(
kKeyESDS, kTypeESDS,
esds->data(), esds->size());
discard = true;
state = SKIP_TO_VOP_START;
}
break;
}
case SKIP_TO_VOP_START:
{
if (chunkType == 0xb6) {
int vopCodingType = (data[offset + 4] & 0xc0) >> 6;
offset += chunkSize;
sp<ABuffer> accessUnit = new ABuffer(offset);
memcpy(accessUnit->data(), data, offset);
memmove(data, &data[offset], size - offset);
size -= offset;
mBuffer->setRange(0, size);
int64_t timeUs = fetchTimestamp(offset);
if (timeUs < 0ll) {
ALOGE("Negative timeus");
return NULL;
}
offset = 0;
accessUnit->meta()->setInt64("timeUs", timeUs);
if (vopCodingType == 0) { // intra-coded VOP
accessUnit->meta()->setInt32("isSync", 1);
}
ALOGV("returning MPEG4 video access unit at time %" PRId64 " us",
timeUs);
// hexdump(accessUnit->data(), accessUnit->size());
return accessUnit;
} else if (chunkType != 0xb3) {
offset += chunkSize;
discard = true;
}
break;
}
default:
ALOGE("Unknown state: %d", state);
return NULL;
}
if (discard) {
(void)fetchTimestamp(offset);
memmove(data, &data[offset], size - offset);
size -= offset;
offset = 0;
mBuffer->setRange(0, size);
} else {
offset += chunkSize;
}
}
return NULL;
}
void ElementaryStreamQueue::signalEOS() {
if (!mEOSReached) {
if (mMode == MPEG_VIDEO) {
const char *theEnd = "\x00\x00\x01\x00";
appendData(theEnd, 4, 0);
}
mEOSReached = true;
} else {
ALOGW("EOS already signaled");
}
}
sp<ABuffer> ElementaryStreamQueue::dequeueAccessUnitMetadata() {
size_t size = mBuffer->size();
if (!size) {
return NULL;
}
sp<ABuffer> accessUnit = new ABuffer(size);
int64_t timeUs = fetchTimestamp(size);
accessUnit->meta()->setInt64("timeUs", timeUs);
memcpy(accessUnit->data(), mBuffer->data(), size);
mBuffer->setRange(0, 0);
if (mFormat == NULL) {
mFormat = new MetaData;
mFormat->setCString(kKeyMIMEType, MEDIA_MIMETYPE_DATA_TIMED_ID3);
}
return accessUnit;
}
void ElementaryStreamQueue::signalNewSampleAesKey(const sp<AMessage> &keyItem) {
if (mSampleDecryptor == NULL) {
ALOGE("signalNewSampleAesKey: Stream %x is not encrypted; keyItem: %p",
mMode, keyItem.get());
return;
}
mSampleDecryptor->signalNewSampleAesKey(keyItem);
}
} // namespace android