From 6a63a939601645404fd98f58c19cc38ca818d99e Mon Sep 17 00:00:00 2001 From: Andreas Huber Date: Fri, 1 Oct 2010 10:51:41 -0700 Subject: Squashed commit of the following: commit 46744c7697f29aec71aed8de3c95ce035c284d97 Author: Andreas Huber Date: Thu Sep 30 16:44:57 2010 -0700 better separation of access units Change-Id: I5a9e2138aed341f0bcf22cfe368a15ca5ea5a73c commit d34952ac0feb1ae722ff65824d7353335502219b Author: Andreas Huber Date: Thu Sep 30 15:35:01 2010 -0700 Support for ES packets that do not start on PES packet boundaries. Change-Id: I2cf012833948eddfb20b16a1901206cf22ce71e4 related-to-bug: 2368598 Change-Id: Ib9329bd6bb7149b5a6e2483788a96b1b158952fc --- media/libstagefright/AwesomePlayer.cpp | 1 + media/libstagefright/avc_utils.cpp | 2 +- media/libstagefright/codecs/avc/dec/AVCDecoder.cpp | 1 + media/libstagefright/include/avc_utils.h | 4 + media/libstagefright/mpeg2ts/ATSParser.cpp | 373 +-------------- media/libstagefright/mpeg2ts/Android.mk | 1 + media/libstagefright/mpeg2ts/ESQueue.cpp | 504 +++++++++++++++++++++ media/libstagefright/mpeg2ts/ESQueue.h | 66 +++ media/libstagefright/mpeg2ts/MPEG2TSExtractor.cpp | 2 +- 9 files changed, 597 insertions(+), 357 deletions(-) create mode 100644 media/libstagefright/mpeg2ts/ESQueue.cpp create mode 100644 media/libstagefright/mpeg2ts/ESQueue.h diff --git a/media/libstagefright/AwesomePlayer.cpp b/media/libstagefright/AwesomePlayer.cpp index 12022bd..0c07866 100644 --- a/media/libstagefright/AwesomePlayer.cpp +++ b/media/libstagefright/AwesomePlayer.cpp @@ -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"); diff --git a/media/libstagefright/avc_utils.cpp b/media/libstagefright/avc_utils.cpp index 511ae12..a8f1104 100644 --- a/media/libstagefright/avc_utils.cpp +++ b/media/libstagefright/avc_utils.cpp @@ -21,7 +21,7 @@ namespace android { -static unsigned parseUE(ABitReader *br) { +unsigned parseUE(ABitReader *br) { unsigned numZeroes = 0; while (br->getBits(1) == 0) { ++numZeroes; diff --git a/media/libstagefright/codecs/avc/dec/AVCDecoder.cpp b/media/libstagefright/codecs/avc/dec/AVCDecoder.cpp index 3c0b736..868c514 100644 --- a/media/libstagefright/codecs/avc/dec/AVCDecoder.cpp +++ b/media/libstagefright/codecs/avc/dec/AVCDecoder.cpp @@ -31,6 +31,7 @@ #include #include #include +#include namespace android { diff --git a/media/libstagefright/include/avc_utils.h b/media/libstagefright/include/avc_utils.h index cc405b5..6602852 100644 --- a/media/libstagefright/include/avc_utils.h +++ b/media/libstagefright/include/avc_utils.h @@ -22,9 +22,13 @@ namespace android { +struct ABitReader; + void FindAVCDimensions( const sp &seqParamSet, int32_t *width, int32_t *height); +unsigned parseUE(ABitReader *br); + } // namespace android #endif // AVC_UTILS_H_ diff --git a/media/libstagefright/mpeg2ts/ATSParser.cpp b/media/libstagefright/mpeg2ts/ATSParser.cpp index 47cca80..bcaab9f 100644 --- a/media/libstagefright/mpeg2ts/ATSParser.cpp +++ b/media/libstagefright/mpeg2ts/ATSParser.cpp @@ -21,6 +21,7 @@ #include "ATSParser.h" #include "AnotherPacketSource.h" +#include "ESQueue.h" #include "include/avc_utils.h" #include @@ -79,6 +80,8 @@ private: sp 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 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 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 MakeAVCCodecSpecificData( - const sp &buffer, int32_t *width, int32_t *height) { - const uint8_t *data = buffer->data(); - size_t size = buffer->size(); - - sp seqParamSet = FindNAL(data, size, 7, NULL); - if (seqParamSet == NULL) { - return NULL; - } - - FindAVCDimensions(seqParamSet, width, height); - - size_t stopOffset; - sp 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 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 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 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 FindMPEG2ADTSConfig( - const sp &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 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 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 meta = new MetaData; - - if (mStreamType == 0x1b) { - meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_AVC); - - int32_t width, height; - sp 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 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); - - if (mStreamType == 0x0f) { - extractAACFrames(buffer); - } - - mSource->queueAccessUnit(buffer); -} - -// 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 &buffer) { - size_t dstOffset = 0; + int64_t timeUs = (PTS * 100) / 9; - size_t offset = 0; - while (offset < buffer->size()) { - CHECK_LE(offset + 7, buffer->size()); + status_t err = mQueue.appendData(data, size, timeUs); + CHECK_EQ(err, (status_t)OK); - ABitReader bits(buffer->data() + offset, buffer->size() - offset); + sp accessUnit; + while ((accessUnit = mQueue.dequeueAccessUnit()) != NULL) { + if (mSource == NULL) { + sp meta = mQueue.getFormat(); - // 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 ATSParser::Stream::getSource(SourceType type) { diff --git a/media/libstagefright/mpeg2ts/Android.mk b/media/libstagefright/mpeg2ts/Android.mk index 3544b4c..4dfc0f7 100644 --- a/media/libstagefright/mpeg2ts/Android.mk +++ b/media/libstagefright/mpeg2ts/Android.mk @@ -5,6 +5,7 @@ include $(CLEAR_VARS) LOCAL_SRC_FILES:= \ AnotherPacketSource.cpp \ ATSParser.cpp \ + ESQueue.cpp \ MPEG2TSExtractor.cpp \ LOCAL_C_INCLUDES:= \ diff --git a/media/libstagefright/mpeg2ts/ESQueue.cpp b/media/libstagefright/mpeg2ts/ESQueue.cpp new file mode 100644 index 0000000..d87040b --- /dev/null +++ b/media/libstagefright/mpeg2ts/ESQueue.cpp @@ -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 + +#include "ESQueue.h" + +#include +#include +#include +#include +#include +#include +#include + +#include "include/avc_utils.h" + +namespace android { + +ElementaryStreamQueue::ElementaryStreamQueue(Mode mode) + : mMode(mode) { +} + +sp 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 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 ElementaryStreamQueue::dequeueAccessUnit() { + if (mMode == H264) { + return dequeueAccessUnitH264(); + } else { + CHECK_EQ((unsigned)mMode, (unsigned)AAC); + return dequeueAccessUnitAAC(); + } +} + +sp ElementaryStreamQueue::dequeueAccessUnitAAC() { + Vector frameOffsets; + Vector 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 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 ElementaryStreamQueue::MakeAACCodecSpecificData( + unsigned profile, unsigned sampling_freq_index, + unsigned channel_configuration) { + sp 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 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 ElementaryStreamQueue::dequeueAccessUnitH264() { + const uint8_t *data = mBuffer->data(); + size_t size = mBuffer->size(); + + Vector 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 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 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 buffer = new ABuffer(nalSize); + memcpy(buffer->data(), nalStart, nalSize); + return buffer; + } + } + + return NULL; +} + +sp ElementaryStreamQueue::MakeAVCCodecSpecificData( + const sp &accessUnit) { + const uint8_t *data = accessUnit->data(); + size_t size = accessUnit->size(); + + sp seqParamSet = FindNAL(data, size, 7, NULL); + if (seqParamSet == NULL) { + return NULL; + } + + int32_t width, height; + FindAVCDimensions(seqParamSet, &width, &height); + + size_t stopOffset; + sp 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 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 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 diff --git a/media/libstagefright/mpeg2ts/ESQueue.h b/media/libstagefright/mpeg2ts/ESQueue.h new file mode 100644 index 0000000..d2e87f2 --- /dev/null +++ b/media/libstagefright/mpeg2ts/ESQueue.h @@ -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 +#include +#include + +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 dequeueAccessUnit(); + + sp getFormat(); + +private: + Mode mMode; + + sp mBuffer; + List mTimestamps; + + sp mFormat; + + sp dequeueAccessUnitH264(); + sp dequeueAccessUnitAAC(); + + static sp MakeAACCodecSpecificData( + unsigned profile, unsigned sampling_freq_index, + unsigned channel_configuration); + + static sp MakeAVCCodecSpecificData( + const sp &accessUnit); + + DISALLOW_EVIL_CONSTRUCTORS(ElementaryStreamQueue); +}; + +} // namespace android + +#endif // ES_QUEUE_H_ diff --git a/media/libstagefright/mpeg2ts/MPEG2TSExtractor.cpp b/media/libstagefright/mpeg2ts/MPEG2TSExtractor.cpp index 2417305..c5257bb 100644 --- a/media/libstagefright/mpeg2ts/MPEG2TSExtractor.cpp +++ b/media/libstagefright/mpeg2ts/MPEG2TSExtractor.cpp @@ -157,7 +157,7 @@ void MPEG2TSExtractor::init() { } } - if (++numPacketsParsed > 1500) { + if (++numPacketsParsed > 2500) { break; } } -- cgit v1.1