blob: 09f52bce8d77206858c6a8ac1b61e69ebafbd08c [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 "APacketSource"
#include <utils/Log.h>
#include "APacketSource.h"
#include "ARawAudioAssembler.h"
#include "ASessionDescription.h"
#include "include/avc_utils.h"
#include <ctype.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/AString.h>
#include <media/stagefright/foundation/base64.h>
#include <media/stagefright/foundation/hexdump.h>
#include <media/stagefright/MediaDefs.h>
#include <media/stagefright/MediaErrors.h>
#include <media/stagefright/MetaData.h>
#include <utils/Vector.h>
namespace android {
static bool GetAttribute(const char *s, const char *key, AString *value) {
value->clear();
size_t keyLen = strlen(key);
for (;;) {
while (isspace(*s)) {
++s;
}
const char *colonPos = strchr(s, ';');
size_t len =
(colonPos == NULL) ? strlen(s) : colonPos - s;
if (len >= keyLen + 1 && s[keyLen] == '=' && !strncmp(s, key, keyLen)) {
value->setTo(&s[keyLen + 1], len - keyLen - 1);
return true;
}
if (colonPos == NULL) {
return false;
}
s = colonPos + 1;
}
}
static sp<ABuffer> decodeHex(const AString &s) {
if ((s.size() % 2) != 0) {
return NULL;
}
size_t outLen = s.size() / 2;
sp<ABuffer> buffer = new ABuffer(outLen);
uint8_t *out = buffer->data();
uint8_t accum = 0;
for (size_t i = 0; i < s.size(); ++i) {
char c = s.c_str()[i];
unsigned value;
if (c >= '0' && c <= '9') {
value = c - '0';
} else if (c >= 'a' && c <= 'f') {
value = c - 'a' + 10;
} else if (c >= 'A' && c <= 'F') {
value = c - 'A' + 10;
} else {
return NULL;
}
accum = (accum << 4) | value;
if (i & 1) {
*out++ = accum;
accum = 0;
}
}
return buffer;
}
static sp<ABuffer> MakeAVCCodecSpecificData(
const char *params, int32_t *width, int32_t *height) {
*width = 0;
*height = 0;
AString val;
sp<ABuffer> profileLevelID = NULL;
if (GetAttribute(params, "profile-level-id", &val)) {
profileLevelID = decodeHex(val);
CHECK_EQ(profileLevelID->size(), 3u);
}
Vector<sp<ABuffer> > paramSets;
size_t numSeqParameterSets = 0;
size_t totalSeqParameterSetSize = 0;
size_t numPicParameterSets = 0;
size_t totalPicParameterSetSize = 0;
if (!GetAttribute(params, "sprop-parameter-sets", &val)) {
return NULL;
}
size_t start = 0;
for (;;) {
ssize_t commaPos = val.find(",", start);
size_t end = (commaPos < 0) ? val.size() : commaPos;
AString nalString(val, start, end - start);
sp<ABuffer> nal = decodeBase64(nalString);
CHECK(nal != NULL);
CHECK_GT(nal->size(), 0u);
CHECK_LE(nal->size(), 65535u);
uint8_t nalType = nal->data()[0] & 0x1f;
if (numSeqParameterSets == 0) {
CHECK_EQ((unsigned)nalType, 7u);
} else if (numPicParameterSets > 0) {
CHECK_EQ((unsigned)nalType, 8u);
}
if (nalType == 7) {
++numSeqParameterSets;
totalSeqParameterSetSize += nal->size();
} else {
CHECK_EQ((unsigned)nalType, 8u);
++numPicParameterSets;
totalPicParameterSetSize += nal->size();
}
paramSets.push(nal);
if (commaPos < 0) {
break;
}
start = commaPos + 1;
}
CHECK_LT(numSeqParameterSets, 32u);
CHECK_LE(numPicParameterSets, 255u);
size_t csdSize =
1 + 3 + 1 + 1
+ 2 * numSeqParameterSets + totalSeqParameterSetSize
+ 1 + 2 * numPicParameterSets + totalPicParameterSetSize;
sp<ABuffer> csd = new ABuffer(csdSize);
uint8_t *out = csd->data();
*out++ = 0x01; // configurationVersion
if (profileLevelID != NULL) {
memcpy(out, profileLevelID->data(), 3);
out += 3;
} else {
*out++ = 0x42; // Baseline profile
*out++ = 0xE0; // Common subset for all profiles
*out++ = 0x0A; // Level 1
}
*out++ = (0x3f << 2) | 1; // lengthSize == 2 bytes
*out++ = 0xe0 | numSeqParameterSets;
for (size_t i = 0; i < numSeqParameterSets; ++i) {
sp<ABuffer> nal = paramSets.editItemAt(i);
*out++ = nal->size() >> 8;
*out++ = nal->size() & 0xff;
memcpy(out, nal->data(), nal->size());
out += nal->size();
if (i == 0) {
FindAVCDimensions(nal, width, height);
ALOGI("dimensions %dx%d", *width, *height);
}
}
*out++ = numPicParameterSets;
for (size_t i = 0; i < numPicParameterSets; ++i) {
sp<ABuffer> nal = paramSets.editItemAt(i + numSeqParameterSets);
*out++ = nal->size() >> 8;
*out++ = nal->size() & 0xff;
memcpy(out, nal->data(), nal->size());
out += nal->size();
}
// hexdump(csd->data(), csd->size());
return csd;
}
sp<ABuffer> MakeAACCodecSpecificData(const char *params) {
AString val;
CHECK(GetAttribute(params, "config", &val));
sp<ABuffer> config = decodeHex(val);
CHECK(config != NULL);
CHECK_GE(config->size(), 4u);
const uint8_t *data = config->data();
uint32_t x = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
x = (x >> 1) & 0xffff;
static const uint8_t kStaticESDS[] = {
0x03, 22,
0x00, 0x00, // ES_ID
0x00, // streamDependenceFlag, URL_Flag, OCRstreamFlag
0x04, 17,
0x40, // Audio ISO/IEC 14496-3
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x05, 2,
// AudioSpecificInfo follows
};
sp<ABuffer> csd = new ABuffer(sizeof(kStaticESDS) + 2);
memcpy(csd->data(), kStaticESDS, sizeof(kStaticESDS));
csd->data()[sizeof(kStaticESDS)] = (x >> 8) & 0xff;
csd->data()[sizeof(kStaticESDS) + 1] = x & 0xff;
// hexdump(csd->data(), csd->size());
return csd;
}
// From mpeg4-generic configuration data.
sp<ABuffer> MakeAACCodecSpecificData2(const char *params) {
AString val;
unsigned long objectType;
if (GetAttribute(params, "objectType", &val)) {
const char *s = val.c_str();
char *end;
objectType = strtoul(s, &end, 10);
CHECK(end > s && *end == '\0');
} else {
objectType = 0x40; // Audio ISO/IEC 14496-3
}
CHECK(GetAttribute(params, "config", &val));
sp<ABuffer> config = decodeHex(val);
CHECK(config != NULL);
// Make sure size fits into a single byte and doesn't have to
// be encoded.
CHECK_LT(20 + config->size(), 128u);
const uint8_t *data = config->data();
static const uint8_t kStaticESDS[] = {
0x03, 22,
0x00, 0x00, // ES_ID
0x00, // streamDependenceFlag, URL_Flag, OCRstreamFlag
0x04, 17,
0x40, // Audio ISO/IEC 14496-3
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x05, 2,
// AudioSpecificInfo follows
};
sp<ABuffer> csd = new ABuffer(sizeof(kStaticESDS) + config->size());
uint8_t *dst = csd->data();
*dst++ = 0x03;
*dst++ = 20 + config->size();
*dst++ = 0x00; // ES_ID
*dst++ = 0x00;
*dst++ = 0x00; // streamDependenceFlag, URL_Flag, OCRstreamFlag
*dst++ = 0x04;
*dst++ = 15 + config->size();
*dst++ = objectType;
for (int i = 0; i < 12; ++i) { *dst++ = 0x00; }
*dst++ = 0x05;
*dst++ = config->size();
memcpy(dst, config->data(), config->size());
// hexdump(csd->data(), csd->size());
return csd;
}
static size_t GetSizeWidth(size_t x) {
size_t n = 1;
while (x > 127) {
++n;
x >>= 7;
}
return n;
}
static uint8_t *EncodeSize(uint8_t *dst, size_t x) {
while (x > 127) {
*dst++ = (x & 0x7f) | 0x80;
x >>= 7;
}
*dst++ = x;
return dst;
}
static bool ExtractDimensionsMPEG4Config(
const sp<ABuffer> &config, int32_t *width, int32_t *height) {
*width = 0;
*height = 0;
const uint8_t *ptr = config->data();
size_t offset = 0;
bool foundVOL = false;
while (offset + 3 < config->size()) {
if (memcmp("\x00\x00\x01", &ptr[offset], 3)
|| (ptr[offset + 3] & 0xf0) != 0x20) {
++offset;
continue;
}
foundVOL = true;
break;
}
if (!foundVOL) {
return false;
}
return ExtractDimensionsFromVOLHeader(
&ptr[offset], config->size() - offset, width, height);
}
static sp<ABuffer> MakeMPEG4VideoCodecSpecificData(
const char *params, int32_t *width, int32_t *height) {
*width = 0;
*height = 0;
AString val;
CHECK(GetAttribute(params, "config", &val));
sp<ABuffer> config = decodeHex(val);
CHECK(config != NULL);
if (!ExtractDimensionsMPEG4Config(config, width, height)) {
return NULL;
}
ALOGI("VOL dimensions = %dx%d", *width, *height);
size_t len1 = config->size() + GetSizeWidth(config->size()) + 1;
size_t len2 = len1 + GetSizeWidth(len1) + 1 + 13;
size_t len3 = len2 + GetSizeWidth(len2) + 1 + 3;
sp<ABuffer> csd = new ABuffer(len3);
uint8_t *dst = csd->data();
*dst++ = 0x03;
dst = EncodeSize(dst, len2 + 3);
*dst++ = 0x00; // ES_ID
*dst++ = 0x00;
*dst++ = 0x00; // streamDependenceFlag, URL_Flag, OCRstreamFlag
*dst++ = 0x04;
dst = EncodeSize(dst, len1 + 13);
*dst++ = 0x01; // Video ISO/IEC 14496-2 Simple Profile
for (size_t i = 0; i < 12; ++i) {
*dst++ = 0x00;
}
*dst++ = 0x05;
dst = EncodeSize(dst, config->size());
memcpy(dst, config->data(), config->size());
dst += config->size();
// hexdump(csd->data(), csd->size());
return csd;
}
APacketSource::APacketSource(
const sp<ASessionDescription> &sessionDesc, size_t index)
: mInitCheck(NO_INIT),
mFormat(new MetaData) {
unsigned long PT;
AString desc;
AString params;
sessionDesc->getFormatType(index, &PT, &desc, &params);
int64_t durationUs;
if (sessionDesc->getDurationUs(&durationUs)) {
mFormat->setInt64(kKeyDuration, durationUs);
} else {
mFormat->setInt64(kKeyDuration, 60 * 60 * 1000000ll);
}
mInitCheck = OK;
if (!strncmp(desc.c_str(), "H264/", 5)) {
mFormat->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_AVC);
int32_t width, height;
if (!sessionDesc->getDimensions(index, PT, &width, &height)) {
width = -1;
height = -1;
}
int32_t encWidth, encHeight;
sp<ABuffer> codecSpecificData =
MakeAVCCodecSpecificData(params.c_str(), &encWidth, &encHeight);
if (codecSpecificData != NULL) {
if (width < 0) {
// If no explicit width/height given in the sdp, use the dimensions
// extracted from the first sequence parameter set.
width = encWidth;
height = encHeight;
}
mFormat->setData(
kKeyAVCC, 0,
codecSpecificData->data(), codecSpecificData->size());
} else if (width < 0) {
mInitCheck = ERROR_UNSUPPORTED;
return;
}
mFormat->setInt32(kKeyWidth, width);
mFormat->setInt32(kKeyHeight, height);
} else if (!strncmp(desc.c_str(), "H263-2000/", 10)
|| !strncmp(desc.c_str(), "H263-1998/", 10)) {
mFormat->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_H263);
int32_t width, height;
if (!sessionDesc->getDimensions(index, PT, &width, &height)) {
mInitCheck = ERROR_UNSUPPORTED;
return;
}
mFormat->setInt32(kKeyWidth, width);
mFormat->setInt32(kKeyHeight, height);
} else if (!strncmp(desc.c_str(), "MP4A-LATM/", 10)) {
mFormat->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_AAC);
int32_t sampleRate, numChannels;
ASessionDescription::ParseFormatDesc(
desc.c_str(), &sampleRate, &numChannels);
mFormat->setInt32(kKeySampleRate, sampleRate);
mFormat->setInt32(kKeyChannelCount, numChannels);
sp<ABuffer> codecSpecificData =
MakeAACCodecSpecificData(params.c_str());
mFormat->setData(
kKeyESDS, 0,
codecSpecificData->data(), codecSpecificData->size());
} else if (!strncmp(desc.c_str(), "AMR/", 4)) {
mFormat->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_AMR_NB);
int32_t sampleRate, numChannels;
ASessionDescription::ParseFormatDesc(
desc.c_str(), &sampleRate, &numChannels);
mFormat->setInt32(kKeySampleRate, sampleRate);
mFormat->setInt32(kKeyChannelCount, numChannels);
if (sampleRate != 8000 || numChannels != 1) {
mInitCheck = ERROR_UNSUPPORTED;
}
} else if (!strncmp(desc.c_str(), "AMR-WB/", 7)) {
mFormat->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_AMR_WB);
int32_t sampleRate, numChannels;
ASessionDescription::ParseFormatDesc(
desc.c_str(), &sampleRate, &numChannels);
mFormat->setInt32(kKeySampleRate, sampleRate);
mFormat->setInt32(kKeyChannelCount, numChannels);
if (sampleRate != 16000 || numChannels != 1) {
mInitCheck = ERROR_UNSUPPORTED;
}
} else if (!strncmp(desc.c_str(), "MP4V-ES/", 8)) {
mFormat->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_MPEG4);
int32_t width, height;
if (!sessionDesc->getDimensions(index, PT, &width, &height)) {
width = -1;
height = -1;
}
int32_t encWidth, encHeight;
sp<ABuffer> codecSpecificData =
MakeMPEG4VideoCodecSpecificData(
params.c_str(), &encWidth, &encHeight);
if (codecSpecificData != NULL) {
mFormat->setData(
kKeyESDS, 0,
codecSpecificData->data(), codecSpecificData->size());
if (width < 0) {
width = encWidth;
height = encHeight;
}
} else if (width < 0) {
mInitCheck = ERROR_UNSUPPORTED;
return;
}
mFormat->setInt32(kKeyWidth, width);
mFormat->setInt32(kKeyHeight, height);
} else if (!strncasecmp(desc.c_str(), "mpeg4-generic/", 14)) {
AString val;
if (!GetAttribute(params.c_str(), "mode", &val)
|| (strcasecmp(val.c_str(), "AAC-lbr")
&& strcasecmp(val.c_str(), "AAC-hbr"))) {
mInitCheck = ERROR_UNSUPPORTED;
return;
}
mFormat->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_AAC);
int32_t sampleRate, numChannels;
ASessionDescription::ParseFormatDesc(
desc.c_str(), &sampleRate, &numChannels);
mFormat->setInt32(kKeySampleRate, sampleRate);
mFormat->setInt32(kKeyChannelCount, numChannels);
mFormat->setInt32(kKeyIsADTS, true);
sp<ABuffer> codecSpecificData =
MakeAACCodecSpecificData2(params.c_str());
mFormat->setData(
kKeyESDS, 0,
codecSpecificData->data(), codecSpecificData->size());
} else if (ARawAudioAssembler::Supports(desc.c_str())) {
ARawAudioAssembler::MakeFormat(desc.c_str(), mFormat);
} else if (!strncasecmp("MP2T/", desc.c_str(), 5)) {
mFormat->setCString(kKeyMIMEType, MEDIA_MIMETYPE_CONTAINER_MPEG2TS);
} else {
mInitCheck = ERROR_UNSUPPORTED;
}
}
APacketSource::~APacketSource() {
}
status_t APacketSource::initCheck() const {
return mInitCheck;
}
sp<MetaData> APacketSource::getFormat() {
return mFormat;
}
} // namespace android