drgreen/android_frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Squashed commit of the following:" into gingerbread

Browse Source
This commit is contained in:
Andreas Huber
2010-10-01 11:01:33 -07:00
committed by Android (Google) Code Review
parent 2942391801 b72c7e36a2
commit d1398db35c
9 changed files with 597 additions and 357 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
media/libstagefright/AwesomePlayer.cpp
View File

@ -274,6 +274,7 @@ status_t AwesomePlayer::setDataSource_l(
status_t AwesomePlayer::setDataSource(
int fd, int64_t offset, int64_t length) {
#if 0
// return setDataSource("httplive://ipad.akamai.com/Video_Content/usat/tt_062209_iphone/440k/prog_index.m3u8");
// return setDataSource("httplive://qthttp.apple.com.edgesuite.net/1009qpeijrfn/sl.m3u8");
return setDataSource("httplive://qthttp.apple.com.edgesuite.net/1009qpeijrfn/0440.m3u8");
// return setDataSource("httplive://qthttp.apple.com.edgesuite.net/1009qpeijrfn/0640.m3u8");

2
media/libstagefright/avc_utils.cpp
View File

@ -21,7 +21,7 @@
namespace android {
static unsigned parseUE(ABitReader *br) {
unsigned parseUE(ABitReader *br) {
unsigned numZeroes = 0;
while (br->getBits(1) == 0) {
++numZeroes;

1
media/libstagefright/codecs/avc/dec/AVCDecoder.cpp
View File

@ -31,6 +31,7 @@
#include <media/stagefright/MediaErrors.h>
#include <media/stagefright/MetaData.h>
#include <media/stagefright/Utils.h>
#include <media/stagefright/foundation/hexdump.h>
namespace android {

4
media/libstagefright/include/avc_utils.h
View File

@ -22,9 +22,13 @@
namespace android {
struct ABitReader;
void FindAVCDimensions(
const sp<ABuffer> &seqParamSet, int32_t *width, int32_t *height);
unsigned parseUE(ABitReader *br);
} // namespace android
#endif // AVC_UTILS_H_

373
media/libstagefright/mpeg2ts/ATSParser.cpp
View File

@ -21,6 +21,7 @@
#include "ATSParser.h"
#include "AnotherPacketSource.h"
#include "ESQueue.h"
#include "include/avc_utils.h"
#include <media/stagefright/foundation/ABitReader.h>
@ -79,6 +80,8 @@ private:
sp<AnotherPacketSource> mSource;
bool mPayloadStarted;
ElementaryStreamQueue mQueue;
void flush();
void parsePES(ABitReader *br);
@ -232,7 +235,9 @@ ATSParser::Stream::Stream(unsigned elementaryPID, unsigned streamType)
: mElementaryPID(elementaryPID),
mStreamType(streamType),
mBuffer(new ABuffer(128 * 1024)),
mPayloadStarted(false) {
mPayloadStarted(false),
mQueue(streamType == 0x1b
? ElementaryStreamQueue::H264 : ElementaryStreamQueue::AAC) {
mBuffer->setRange(0, 0);
}
@ -433,373 +438,31 @@ void ATSParser::Stream::flush() {
mBuffer->setRange(0, 0);
}
static sp<ABuffer> FindNAL(
const uint8_t *data, size_t size, unsigned nalType,
size_t *stopOffset) {
bool foundStart = false;
size_t startOffset = 0;
size_t offset = 0;
for (;;) {
while (offset + 3 < size
&& memcmp("\x00\x00\x00\x01", &data[offset], 4)) {
++offset;
}
if (foundStart) {
size_t nalSize;
if (offset + 3 >= size) {
nalSize = size - startOffset;
} else {
nalSize = offset - startOffset;
}
sp<ABuffer> nal = new ABuffer(nalSize);
memcpy(nal->data(), &data[startOffset], nalSize);
if (stopOffset != NULL) {
*stopOffset = startOffset + nalSize;
}
return nal;
}
if (offset + 4 >= size) {
return NULL;
}
if ((data[offset + 4] & 0x1f) == nalType) {
foundStart = true;
startOffset = offset + 4;
}
offset += 4;
}
}
static sp<ABuffer> MakeAVCCodecSpecificData(
const sp<ABuffer> &buffer, int32_t *width, int32_t *height) {
const uint8_t *data = buffer->data();
size_t size = buffer->size();
sp<ABuffer> seqParamSet = FindNAL(data, size, 7, NULL);
if (seqParamSet == NULL) {
return NULL;
}
FindAVCDimensions(seqParamSet, width, height);
size_t stopOffset;
sp<ABuffer> picParamSet = FindNAL(data, size, 8, &stopOffset);
CHECK(picParamSet != NULL);
buffer->setRange(stopOffset, size - stopOffset);
LOGV("buffer has %d bytes left.", buffer->size());
size_t csdSize =
1 + 3 + 1 + 1
+ 2 * 1 + seqParamSet->size()
+ 1 + 2 * 1 + picParamSet->size();
sp<ABuffer> csd = new ABuffer(csdSize);
uint8_t *out = csd->data();
*out++ = 0x01; // configurationVersion
memcpy(out, seqParamSet->data() + 1, 3); // profile/level...
out += 3;
*out++ = (0x3f << 2) | 1; // lengthSize == 2 bytes
*out++ = 0xe0 | 1;
*out++ = seqParamSet->size() >> 8;
*out++ = seqParamSet->size() & 0xff;
memcpy(out, seqParamSet->data(), seqParamSet->size());
out += seqParamSet->size();
*out++ = 1;
*out++ = picParamSet->size() >> 8;
*out++ = picParamSet->size() & 0xff;
memcpy(out, picParamSet->data(), picParamSet->size());
return csd;
}
static bool getNextNALUnit(
const uint8_t **_data, size_t *_size,
const uint8_t **nalStart, size_t *nalSize) {
const uint8_t *data = *_data;
size_t size = *_size;
// hexdump(data, size);
*nalStart = NULL;
*nalSize = 0;
if (size == 0) {
return false;
}
size_t offset = 0;
for (;;) {
CHECK_LT(offset + 2, size);
if (!memcmp("\x00\x00\x01", &data[offset], 3)) {
break;
}
CHECK_EQ((unsigned)data[offset], 0x00u);
++offset;
}
offset += 3;
size_t startOffset = offset;
while (offset + 2 < size
&& memcmp("\x00\x00\x00", &data[offset], 3)
&& memcmp("\x00\x00\x01", &data[offset], 3)) {
++offset;
}
if (offset + 2 >= size) {
*nalStart = &data[startOffset];
*nalSize = size - startOffset;
*_data = NULL;
*_size = 0;
return true;
}
size_t endOffset = offset;
while (offset + 2 < size && memcmp("\x00\x00\x01", &data[offset], 3)) {
CHECK_EQ((unsigned)data[offset], 0x00u);
++offset;
}
*nalStart = &data[startOffset];
*nalSize = endOffset - startOffset;
if (offset + 2 < size) {
*_data = &data[offset];
*_size = size - offset;
} else {
*_data = NULL;
*_size = 0;
}
return true;
}
sp<ABuffer> MakeCleanAVCData(const uint8_t *data, size_t size) {
// hexdump(data, size);
const uint8_t *tmpData = data;
size_t tmpSize = size;
size_t totalSize = 0;
const uint8_t *nalStart;
size_t nalSize;
while (getNextNALUnit(&tmpData, &tmpSize, &nalStart, &nalSize)) {
// hexdump(nalStart, nalSize);
totalSize += 4 + nalSize;
}
sp<ABuffer> buffer = new ABuffer(totalSize);
size_t offset = 0;
while (getNextNALUnit(&data, &size, &nalStart, &nalSize)) {
memcpy(buffer->data() + offset, "\x00\x00\x00\x01", 4);
memcpy(buffer->data() + offset + 4, nalStart, nalSize);
offset += 4 + nalSize;
}
return buffer;
}
static sp<ABuffer> FindMPEG2ADTSConfig(
const sp<ABuffer> &buffer, int32_t *sampleRate, int32_t *channelCount) {
ABitReader br(buffer->data(), buffer->size());
CHECK_EQ(br.getBits(12), 0xfffu);
CHECK_EQ(br.getBits(1), 0u);
CHECK_EQ(br.getBits(2), 0u);
br.getBits(1); // protection_absent
unsigned profile = br.getBits(2);
LOGV("profile = %u", profile);
CHECK_NE(profile, 3u);
unsigned sampling_freq_index = br.getBits(4);
br.getBits(1); // private_bit
unsigned channel_configuration = br.getBits(3);
CHECK_NE(channel_configuration, 0u);
LOGV("sampling_freq_index = %u", sampling_freq_index);
LOGV("channel_configuration = %u", channel_configuration);
CHECK_LE(sampling_freq_index, 11u);
static const int32_t kSamplingFreq[] = {
96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050,
16000, 12000, 11025, 8000
};
*sampleRate = kSamplingFreq[sampling_freq_index];
*channelCount = channel_configuration;
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
// oooo offf fccc c000
// o - audioObjectType
// f - samplingFreqIndex
// c - channelConfig
};
sp<ABuffer> csd = new ABuffer(sizeof(kStaticESDS) + 2);
memcpy(csd->data(), kStaticESDS, sizeof(kStaticESDS));
csd->data()[sizeof(kStaticESDS)] =
((profile + 1) << 3) | (sampling_freq_index >> 1);
csd->data()[sizeof(kStaticESDS) + 1] =
((sampling_freq_index << 7) & 0x80) | (channel_configuration << 3);
// hexdump(csd->data(), csd->size());
return csd;
}
void ATSParser::Stream::onPayloadData(
unsigned PTS_DTS_flags, uint64_t PTS, uint64_t DTS,
const uint8_t *data, size_t size) {
LOGV("onPayloadData mStreamType=0x%02x", mStreamType);
sp<ABuffer> buffer;
if (mStreamType == 0x1b) {
buffer = MakeCleanAVCData(data, size);
} else {
// hexdump(data, size);
buffer = new ABuffer(size);
memcpy(buffer->data(), data, size);
}
if (mSource == NULL) {
sp<MetaData> meta = new MetaData;
if (mStreamType == 0x1b) {
meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_AVC);
int32_t width, height;
sp<ABuffer> csd = MakeAVCCodecSpecificData(buffer, &width, &height);
if (csd == NULL) {
return;
}
meta->setData(kKeyAVCC, 0, csd->data(), csd->size());
meta->setInt32(kKeyWidth, width);
meta->setInt32(kKeyHeight, height);
} else {
CHECK_EQ(mStreamType, 0x0fu);
meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_AAC);
int32_t sampleRate, channelCount;
sp<ABuffer> csd =
FindMPEG2ADTSConfig(buffer, &sampleRate, &channelCount);
LOGV("sampleRate = %d", sampleRate);
LOGV("channelCount = %d", channelCount);
meta->setInt32(kKeySampleRate, sampleRate);
meta->setInt32(kKeyChannelCount, channelCount);
meta->setData(kKeyESDS, 0, csd->data(), csd->size());
}
LOGV("created source!");
mSource = new AnotherPacketSource(meta);
// fall through
}
CHECK(PTS_DTS_flags == 2 || PTS_DTS_flags == 3);
buffer->meta()->setInt64("time", (PTS * 100) / 9);
int64_t timeUs = (PTS * 100) / 9;
if (mStreamType == 0x0f) {
extractAACFrames(buffer);
}
status_t err = mQueue.appendData(data, size, timeUs);
CHECK_EQ(err, (status_t)OK);
mSource->queueAccessUnit(buffer);
}
sp<ABuffer> accessUnit;
while ((accessUnit = mQueue.dequeueAccessUnit()) != NULL) {
if (mSource == NULL) {
sp<MetaData> meta = mQueue.getFormat();
// Disassemble one or more ADTS frames into their constituent parts and
// leave only the concatenated raw_data_blocks in the buffer.
void ATSParser::Stream::extractAACFrames(const sp<ABuffer> &buffer) {
size_t dstOffset = 0;
size_t offset = 0;
while (offset < buffer->size()) {
CHECK_LE(offset + 7, buffer->size());
ABitReader bits(buffer->data() + offset, buffer->size() - offset);
// adts_fixed_header
CHECK_EQ(bits.getBits(12), 0xfffu);
bits.skipBits(3); // ID, layer
bool protection_absent = bits.getBits(1) != 0;
// 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);
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) {
size_t scan = offset + aac_frame_length;
offset += 7;
if (!protection_absent) {
offset += 2;
if (meta != NULL) {
LOGV("created source!");
mSource = new AnotherPacketSource(meta);
mSource->queueAccessUnit(accessUnit);
}
CHECK_LE(scan, buffer->size());
LOGV("found aac raw data block at [0x%08x ; 0x%08x)", offset, scan);
memmove(&buffer->data()[dstOffset], &buffer->data()[offset],
scan - offset);
dstOffset += scan - offset;
offset = scan;
} else {
// To be implemented.
TRESPASS();
mSource->queueAccessUnit(accessUnit);
}
}
CHECK_EQ(offset, buffer->size());
buffer->setRange(buffer->offset(), dstOffset);
}
sp<MediaSource> ATSParser::Stream::getSource(SourceType type) {

1
media/libstagefright/mpeg2ts/Android.mk
View File

@ -5,6 +5,7 @@ include $(CLEAR_VARS)
LOCAL_SRC_FILES:= \
AnotherPacketSource.cpp \
ATSParser.cpp \
ESQueue.cpp \
MPEG2TSExtractor.cpp \
LOCAL_C_INCLUDES:= \

504
media/libstagefright/mpeg2ts/ESQueue.cpp Normal file
View File

@ -0,0 +1,504 @@
/*
* 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 "include/avc_utils.h"
namespace android {
ElementaryStreamQueue::ElementaryStreamQueue(Mode mode)
: mMode(mode) {
}
sp<MetaData> ElementaryStreamQueue::getFormat() {
return mFormat;
}
static status_t getNextNALUnit(
const uint8_t **_data, size_t *_size,
const uint8_t **nalStart, size_t *nalSize,
bool startCodeFollows = false) {
const uint8_t *data = *_data;
size_t size = *_size;
*nalStart = NULL;
*nalSize = 0;
if (size == 0) {
return -EAGAIN;
}
// Skip any number of leading 0x00.
size_t offset = 0;
while (offset < size && data[offset] == 0x00) {
++offset;
}
if (offset == size) {
return -EAGAIN;
}
// A valid startcode consists of at least two 0x00 bytes followed by 0x01.
if (offset < 2 || data[offset] != 0x01) {
return ERROR_MALFORMED;
}
++offset;
size_t startOffset = offset;
for (;;) {
while (offset < size && data[offset] != 0x01) {
++offset;
}
if (offset == size) {
if (startCodeFollows) {
offset = size + 2;
break;
}
return -EAGAIN;
}
if (data[offset - 1] == 0x00 && data[offset - 2] == 0x00) {
break;
}
++offset;
}
size_t endOffset = offset - 2;
while (data[endOffset - 1] == 0x00) {
--endOffset;
}
*nalStart = &data[startOffset];
*nalSize = endOffset - startOffset;
if (offset + 2 < size) {
*_data = &data[offset - 2];
*_size = size - offset + 2;
} else {
*_data = NULL;
*_size = 0;
}
return OK;
}
status_t ElementaryStreamQueue::appendData(
const void *data, size_t size, int64_t timeUs) {
if (mBuffer == NULL || mBuffer->size() == 0) {
switch (mMode) {
case H264:
{
if (size < 4 || memcmp("\x00\x00\x00\x01", data, 4)) {
return ERROR_MALFORMED;
}
break;
}
case AAC:
{
uint8_t *ptr = (uint8_t *)data;
if (size < 2 || ptr[0] != 0xff || (ptr[1] >> 4) != 0x0f) {
return ERROR_MALFORMED;
}
break;
}
default:
TRESPASS();
break;
}
}
size_t neededSize = (mBuffer == NULL ? 0 : mBuffer->size()) + size;
if (mBuffer == NULL || neededSize > mBuffer->capacity()) {
neededSize = (neededSize + 65535) & ~65535;
LOGI("resizing buffer to size %d", 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);
mTimestamps.push_back(timeUs);
return OK;
}
sp<ABuffer> ElementaryStreamQueue::dequeueAccessUnit() {
if (mMode == H264) {
return dequeueAccessUnitH264();
} else {
CHECK_EQ((unsigned)mMode, (unsigned)AAC);
return dequeueAccessUnitAAC();
}
}
sp<ABuffer> ElementaryStreamQueue::dequeueAccessUnitAAC() {
Vector<size_t> frameOffsets;
Vector<size_t> frameSizes;
size_t auSize = 0;
size_t offset = 0;
while (offset + 7 <= mBuffer->size()) {
ABitReader bits(mBuffer->data() + offset, mBuffer->size() - offset);
// adts_fixed_header
CHECK_EQ(bits.getBits(12), 0xfffu);
bits.skipBits(3); // ID, layer
bool protection_absent = bits.getBits(1) != 0;
if (mFormat == NULL) {
unsigned profile = bits.getBits(2);
CHECK_NE(profile, 3u);
unsigned sampling_freq_index = bits.getBits(4);
bits.getBits(1); // private_bit
unsigned channel_configuration = bits.getBits(3);
CHECK_NE(channel_configuration, 0u);
bits.skipBits(2); // original_copy, home
mFormat = MakeAACCodecSpecificData(
profile, sampling_freq_index, channel_configuration);
} 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);
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.
TRESPASS();
}
if (offset + aac_frame_length > mBuffer->size()) {
break;
}
size_t headerSize = protection_absent ? 7 : 9;
frameOffsets.push(offset + headerSize);
frameSizes.push(aac_frame_length - headerSize);
auSize += aac_frame_length - headerSize;
offset += aac_frame_length;
}
if (offset == 0) {
return NULL;
}
sp<ABuffer> accessUnit = new ABuffer(auSize);
size_t dstOffset = 0;
for (size_t i = 0; i < frameOffsets.size(); ++i) {
memcpy(accessUnit->data() + dstOffset,
mBuffer->data() + frameOffsets.itemAt(i),
frameSizes.itemAt(i));
dstOffset += frameSizes.itemAt(i);
}
memmove(mBuffer->data(), mBuffer->data() + offset,
mBuffer->size() - offset);
mBuffer->setRange(0, mBuffer->size() - offset);
CHECK_GT(mTimestamps.size(), 0u);
int64_t timeUs = *mTimestamps.begin();
mTimestamps.erase(mTimestamps.begin());
accessUnit->meta()->setInt64("time", timeUs);
return accessUnit;
}
// static
sp<MetaData> ElementaryStreamQueue::MakeAACCodecSpecificData(
unsigned profile, unsigned sampling_freq_index,
unsigned channel_configuration) {
sp<MetaData> meta = new MetaData;
meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_AAC);
CHECK_LE(sampling_freq_index, 11u);
static const int32_t kSamplingFreq[] = {
96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050,
16000, 12000, 11025, 8000
};
meta->setInt32(kKeySampleRate, kSamplingFreq[sampling_freq_index]);
meta->setInt32(kKeyChannelCount, channel_configuration);
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
// oooo offf fccc c000
// o - audioObjectType
// f - samplingFreqIndex
// c - channelConfig
};
sp<ABuffer> csd = new ABuffer(sizeof(kStaticESDS) + 2);
memcpy(csd->data(), kStaticESDS, sizeof(kStaticESDS));
csd->data()[sizeof(kStaticESDS)] =
((profile + 1) << 3) | (sampling_freq_index >> 1);
csd->data()[sizeof(kStaticESDS) + 1] =
((sampling_freq_index << 7) & 0x80) | (channel_configuration << 3);
meta->setData(kKeyESDS, 0, csd->data(), csd->size());
return meta;
}
struct NALPosition {
size_t nalOffset;
size_t nalSize;
};
sp<ABuffer> ElementaryStreamQueue::dequeueAccessUnitH264() {
const uint8_t *data = mBuffer->data();
size_t size = mBuffer->size();
Vector<NALPosition> nals;
size_t totalSize = 0;
status_t err;
const uint8_t *nalStart;
size_t nalSize;
bool foundSlice = false;
while ((err = getNextNALUnit(&data, &size, &nalStart, &nalSize)) == OK) {
CHECK_GT(nalSize, 0u);
unsigned nalType = nalStart[0] & 0x1f;
bool flush = false;
if (nalType == 1 || nalType == 5) {
if (foundSlice) {
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;
}
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);
#if !LOG_NDEBUG
AString out;
#endif
size_t dstOffset = 0;
for (size_t i = 0; i < nals.size(); ++i) {
const NALPosition &pos = nals.itemAt(i);
unsigned nalType = mBuffer->data()[pos.nalOffset] & 0x1f;
#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);
memcpy(accessUnit->data() + dstOffset + 4,
mBuffer->data() + pos.nalOffset,
pos.nalSize);
dstOffset += pos.nalSize + 4;
}
LOGV("accessUnit contains nal types %s", out.c_str());
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);
CHECK_GT(mTimestamps.size(), 0u);
int64_t timeUs = *mTimestamps.begin();
mTimestamps.erase(mTimestamps.begin());
accessUnit->meta()->setInt64("time", timeUs);
if (mFormat == NULL) {
mFormat = MakeAVCCodecSpecificData(accessUnit);
}
return accessUnit;
}
NALPosition pos;
pos.nalOffset = nalStart - mBuffer->data();
pos.nalSize = nalSize;
nals.push(pos);
totalSize += nalSize;
}
CHECK_EQ(err, (status_t)-EAGAIN);
return NULL;
}
static sp<ABuffer> FindNAL(
const uint8_t *data, size_t size, unsigned nalType,
size_t *stopOffset) {
const uint8_t *nalStart;
size_t nalSize;
while (getNextNALUnit(&data, &size, &nalStart, &nalSize, true) == OK) {
if ((nalStart[0] & 0x1f) == nalType) {
sp<ABuffer> buffer = new ABuffer(nalSize);
memcpy(buffer->data(), nalStart, nalSize);
return buffer;
}
}
return NULL;
}
sp<MetaData> ElementaryStreamQueue::MakeAVCCodecSpecificData(
const sp<ABuffer> &accessUnit) {
const uint8_t *data = accessUnit->data();
size_t size = accessUnit->size();
sp<ABuffer> seqParamSet = FindNAL(data, size, 7, NULL);
if (seqParamSet == NULL) {
return NULL;
}
int32_t width, height;
FindAVCDimensions(seqParamSet, &width, &height);
size_t stopOffset;
sp<ABuffer> picParamSet = FindNAL(data, size, 8, &stopOffset);
CHECK(picParamSet != NULL);
size_t csdSize =
1 + 3 + 1 + 1
+ 2 * 1 + seqParamSet->size()
+ 1 + 2 * 1 + picParamSet->size();
sp<ABuffer> csd = new ABuffer(csdSize);
uint8_t *out = csd->data();
*out++ = 0x01; // configurationVersion
memcpy(out, seqParamSet->data() + 1, 3); // profile/level...
out += 3;
*out++ = (0x3f << 2) | 1; // lengthSize == 2 bytes
*out++ = 0xe0 | 1;
*out++ = seqParamSet->size() >> 8;
*out++ = seqParamSet->size() & 0xff;
memcpy(out, seqParamSet->data(), seqParamSet->size());
out += seqParamSet->size();
*out++ = 1;
*out++ = picParamSet->size() >> 8;
*out++ = picParamSet->size() & 0xff;
memcpy(out, picParamSet->data(), picParamSet->size());
#if 0
LOGI("AVC seq param set");
hexdump(seqParamSet->data(), seqParamSet->size());
#endif
sp<MetaData> meta = new MetaData;
meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_AVC);
meta->setData(kKeyAVCC, 0, csd->data(), csd->size());
meta->setInt32(kKeyWidth, width);
meta->setInt32(kKeyHeight, height);
return meta;
}
} // namespace android

66
media/libstagefright/mpeg2ts/ESQueue.h Normal file
View File

@ -0,0 +1,66 @@
/*
* 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.
*/
#ifndef ES_QUEUE_H_
#define ES_QUEUE_H_
#include <media/stagefright/foundation/ABase.h>
#include <utils/List.h>
#include <utils/RefBase.h>
namespace android {
struct ABuffer;
struct MetaData;
struct ElementaryStreamQueue {
enum Mode {
H264,
AAC
};
ElementaryStreamQueue(Mode mode);
status_t appendData(const void *data, size_t size, int64_t timeUs);
sp<ABuffer> dequeueAccessUnit();
sp<MetaData> getFormat();
private:
Mode mMode;
sp<ABuffer> mBuffer;
List<int64_t> mTimestamps;
sp<MetaData> mFormat;
sp<ABuffer> dequeueAccessUnitH264();
sp<ABuffer> dequeueAccessUnitAAC();
static sp<MetaData> MakeAACCodecSpecificData(
unsigned profile, unsigned sampling_freq_index,
unsigned channel_configuration);
static sp<MetaData> MakeAVCCodecSpecificData(
const sp<ABuffer> &accessUnit);
DISALLOW_EVIL_CONSTRUCTORS(ElementaryStreamQueue);
};
} // namespace android
#endif // ES_QUEUE_H_

2
media/libstagefright/mpeg2ts/MPEG2TSExtractor.cpp
View File

@ -157,7 +157,7 @@ void MPEG2TSExtractor::init() {
}
}
if (++numPacketsParsed > 1500) {
if (++numPacketsParsed > 2500) {
break;
}
}