Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Support mpeg1,2 audio and mpeg1,2,4 video content extraction from .ts streams."

Browse Source
This commit is contained in:
Andreas Huber
2011-05-26 08:52:55 -07:00
committed by Android (Google) Code Review
parent 31beb6db09 eb2f9c193d
commit 73a4b2b3be
18 changed files with 893 additions and 280 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
include/media/stagefright/MediaDefs.h
View File

@@ -26,6 +26,7 @@ extern const char *MEDIA_MIMETYPE_VIDEO_VPX;
extern const char *MEDIA_MIMETYPE_VIDEO_AVC;
extern const char *MEDIA_MIMETYPE_VIDEO_MPEG4;
extern const char *MEDIA_MIMETYPE_VIDEO_H263;
extern const char *MEDIA_MIMETYPE_VIDEO_MPEG2;
extern const char *MEDIA_MIMETYPE_VIDEO_RAW;
extern const char *MEDIA_MIMETYPE_AUDIO_AMR_NB;

4
media/libmediaplayerservice/nuplayer/HTTPLiveSource.cpp
View File

@@ -77,7 +77,7 @@ void NuPlayer::HTTPLiveSource::start() {
sp<MetaData> NuPlayer::HTTPLiveSource::getFormat(bool audio) {
ATSParser::SourceType type =
audio ? ATSParser::MPEG2ADTS_AUDIO : ATSParser::AVC_VIDEO;
audio ? ATSParser::AUDIO : ATSParser::VIDEO;
sp<AnotherPacketSource> source =
static_cast<AnotherPacketSource *>(mTSParser->getSource(type).get());
@@ -131,7 +131,7 @@ bool NuPlayer::HTTPLiveSource::feedMoreTSData() {
status_t NuPlayer::HTTPLiveSource::dequeueAccessUnit(
bool audio, sp<ABuffer> *accessUnit) {
ATSParser::SourceType type =
audio ? ATSParser::MPEG2ADTS_AUDIO : ATSParser::AVC_VIDEO;
audio ? ATSParser::AUDIO : ATSParser::VIDEO;
sp<AnotherPacketSource> source =
static_cast<AnotherPacketSource *>(mTSParser->getSource(type).get());

4
media/libmediaplayerservice/nuplayer/StreamingSource.cpp
View File

@@ -87,7 +87,7 @@ bool NuPlayer::StreamingSource::feedMoreTSData() {
sp<MetaData> NuPlayer::StreamingSource::getFormat(bool audio) {
ATSParser::SourceType type =
audio ? ATSParser::MPEG2ADTS_AUDIO : ATSParser::AVC_VIDEO;
audio ? ATSParser::AUDIO : ATSParser::VIDEO;
sp<AnotherPacketSource> source =
static_cast<AnotherPacketSource *>(mTSParser->getSource(type).get());
@@ -102,7 +102,7 @@ sp<MetaData> NuPlayer::StreamingSource::getFormat(bool audio) {
status_t NuPlayer::StreamingSource::dequeueAccessUnit(
bool audio, sp<ABuffer> *accessUnit) {
ATSParser::SourceType type =
audio ? ATSParser::MPEG2ADTS_AUDIO : ATSParser::AVC_VIDEO;
audio ? ATSParser::AUDIO : ATSParser::VIDEO;
sp<AnotherPacketSource> source =
static_cast<AnotherPacketSource *>(mTSParser->getSource(type).get());

9
media/libstagefright/ACodec.cpp
View File

@@ -909,6 +909,8 @@ status_t ACodec::setupVideoDecoder(
compressionFormat = OMX_VIDEO_CodingMPEG4;
} else if (!strcasecmp(MEDIA_MIMETYPE_VIDEO_H263, mime)) {
compressionFormat = OMX_VIDEO_CodingH263;
} else if (!strcasecmp(MEDIA_MIMETYPE_VIDEO_MPEG2, mime)) {
compressionFormat = OMX_VIDEO_CodingMPEG2;
} else {
TRESPASS();
}
@@ -1647,6 +1649,10 @@ void ACodec::UninitializedState::onSetup(
componentName = "OMX.google.aac.decoder";
} else if (!strcasecmp(mime.c_str(), MEDIA_MIMETYPE_AUDIO_MPEG)) {
componentName = "OMX.Nvidia.mp3.decoder";
} else if (!strcasecmp(mime.c_str(), MEDIA_MIMETYPE_VIDEO_MPEG2)) {
componentName = "OMX.Nvidia.mpeg2v.decode";
} else if (!strcasecmp(mime.c_str(), MEDIA_MIMETYPE_VIDEO_MPEG4)) {
componentName = "OMX.google.mpeg4.decoder";
} else {
TRESPASS();
}
@@ -1670,7 +1676,8 @@ void ACodec::UninitializedState::onSetup(
mCodec->configureCodec(mime.c_str(), msg);
sp<RefBase> obj;
if (msg->findObject("native-window", &obj)) {
if (msg->findObject("native-window", &obj)
&& strncmp("OMX.google.", componentName.c_str(), 11)) {
sp<NativeWindowWrapper> nativeWindow(
static_cast<NativeWindowWrapper *>(obj.get()));
CHECK(nativeWindow != NULL);

164
media/libstagefright/MP3Extractor.cpp
View File

@@ -20,6 +20,7 @@
#include "include/MP3Extractor.h"
#include "include/avc_utils.h"
#include "include/ID3.h"
#include "include/VBRISeeker.h"
#include "include/XINGSeeker.h"
@@ -44,158 +45,6 @@ namespace android {
// Yes ... there are things that must indeed match...
static const uint32_t kMask = 0xfffe0c00;
// static
bool MP3Extractor::get_mp3_frame_size(
uint32_t header, size_t *frame_size,
int *out_sampling_rate, int *out_channels,
int *out_bitrate, int *out_num_samples) {
*frame_size = 0;
if (out_sampling_rate) {
*out_sampling_rate = 0;
}
if (out_channels) {
*out_channels = 0;
}
if (out_bitrate) {
*out_bitrate = 0;
}
if (out_num_samples) {
*out_num_samples = 1152;
}
if ((header & 0xffe00000) != 0xffe00000) {
return false;
}
unsigned version = (header >> 19) & 3;
if (version == 0x01) {
return false;
}
unsigned layer = (header >> 17) & 3;
if (layer == 0x00) {
return false;
}
unsigned protection = (header >> 16) & 1;
unsigned bitrate_index = (header >> 12) & 0x0f;
if (bitrate_index == 0 || bitrate_index == 0x0f) {
// Disallow "free" bitrate.
return false;
}
unsigned sampling_rate_index = (header >> 10) & 3;
if (sampling_rate_index == 3) {
return false;
}
static const int kSamplingRateV1[] = { 44100, 48000, 32000 };
int sampling_rate = kSamplingRateV1[sampling_rate_index];
if (version == 2 /* V2 */) {
sampling_rate /= 2;
} else if (version == 0 /* V2.5 */) {
sampling_rate /= 4;
}
unsigned padding = (header >> 9) & 1;
if (layer == 3) {
// layer I
static const int kBitrateV1[] = {
32, 64, 96, 128, 160, 192, 224, 256,
288, 320, 352, 384, 416, 448
};
static const int kBitrateV2[] = {
32, 48, 56, 64, 80, 96, 112, 128,
144, 160, 176, 192, 224, 256
};
int bitrate =
(version == 3 /* V1 */)
? kBitrateV1[bitrate_index - 1]
: kBitrateV2[bitrate_index - 1];
if (out_bitrate) {
*out_bitrate = bitrate;
}
*frame_size = (12000 * bitrate / sampling_rate + padding) * 4;
if (out_num_samples) {
*out_num_samples = 384;
}
} else {
// layer II or III
static const int kBitrateV1L2[] = {
32, 48, 56, 64, 80, 96, 112, 128,
160, 192, 224, 256, 320, 384
};
static const int kBitrateV1L3[] = {
32, 40, 48, 56, 64, 80, 96, 112,
128, 160, 192, 224, 256, 320
};
static const int kBitrateV2[] = {
8, 16, 24, 32, 40, 48, 56, 64,
80, 96, 112, 128, 144, 160
};
int bitrate;
if (version == 3 /* V1 */) {
bitrate = (layer == 2 /* L2 */)
? kBitrateV1L2[bitrate_index - 1]
: kBitrateV1L3[bitrate_index - 1];
if (out_num_samples) {
*out_num_samples = 1152;
}
} else {
// V2 (or 2.5)
bitrate = kBitrateV2[bitrate_index - 1];
if (out_num_samples) {
*out_num_samples = 576;
}
}
if (out_bitrate) {
*out_bitrate = bitrate;
}
if (version == 3 /* V1 */) {
*frame_size = 144000 * bitrate / sampling_rate + padding;
} else {
// V2 or V2.5
*frame_size = 72000 * bitrate / sampling_rate + padding;
}
}
if (out_sampling_rate) {
*out_sampling_rate = sampling_rate;
}
if (out_channels) {
int channel_mode = (header >> 6) & 3;
*out_channels = (channel_mode == 3) ? 1 : 2;
}
return true;
}
static bool Resync(
const sp<DataSource> &source, uint32_t match_header,
off64_t *inout_pos, off64_t *post_id3_pos, uint32_t *out_header) {
@@ -297,7 +146,7 @@ static bool Resync(
size_t frame_size;
int sample_rate, num_channels, bitrate;
if (!MP3Extractor::get_mp3_frame_size(
if (!GetMPEGAudioFrameSize(
header, &frame_size,
&sample_rate, &num_channels, &bitrate)) {
++pos;
@@ -331,7 +180,7 @@ static bool Resync(
}
size_t test_frame_size;
if (!MP3Extractor::get_mp3_frame_size(
if (!GetMPEGAudioFrameSize(
test_header, &test_frame_size)) {
valid = false;
break;
@@ -437,7 +286,7 @@ MP3Extractor::MP3Extractor(
int sample_rate;
int num_channels;
int bitrate;
get_mp3_frame_size(
GetMPEGAudioFrameSize(
header, &frame_size, &sample_rate, &num_channels, &bitrate);
mMeta = new MetaData;
@@ -602,8 +451,9 @@ status_t MP3Source::read(
uint32_t header = U32_AT((const uint8_t *)buffer->data());
if ((header & kMask) == (mFixedHeader & kMask)
&& MP3Extractor::get_mp3_frame_size(
header, &frame_size, &sample_rate, NULL, &bitrate, &num_samples)) {
&& GetMPEGAudioFrameSize(
header, &frame_size, &sample_rate, NULL,
&bitrate, &num_samples)) {
break;
}

1
media/libstagefright/MediaDefs.cpp
View File

@@ -24,6 +24,7 @@ const char *MEDIA_MIMETYPE_VIDEO_VPX = "video/x-vnd.on2.vp8";
const char *MEDIA_MIMETYPE_VIDEO_AVC = "video/avc";
const char *MEDIA_MIMETYPE_VIDEO_MPEG4 = "video/mp4v-es";
const char *MEDIA_MIMETYPE_VIDEO_H263 = "video/3gpp";
const char *MEDIA_MIMETYPE_VIDEO_MPEG2 = "video/mpeg2";
const char *MEDIA_MIMETYPE_VIDEO_RAW = "video/raw";
const char *MEDIA_MIMETYPE_AUDIO_AMR_NB = "audio/3gpp";

8
media/libstagefright/OMXCodec.cpp
View File

@@ -163,7 +163,6 @@ static sp<MediaSource> InstantiateSoftwareCodec(
static const CodecInfo kDecoderInfo[] = {
{ MEDIA_MIMETYPE_IMAGE_JPEG, "OMX.TI.JPEG.decode" },
// { MEDIA_MIMETYPE_AUDIO_MPEG, "OMX.Nvidia.mp3.decoder" },
// { MEDIA_MIMETYPE_AUDIO_MPEG, "OMX.TI.MP3.decode" },
{ MEDIA_MIMETYPE_AUDIO_MPEG, "OMX.google.mp3.decoder" },
{ MEDIA_MIMETYPE_AUDIO_MPEG, "MP3Decoder" },
@@ -207,6 +206,7 @@ static const CodecInfo kDecoderInfo[] = {
{ MEDIA_MIMETYPE_AUDIO_VORBIS, "VorbisDecoder" },
{ MEDIA_MIMETYPE_VIDEO_VPX, "OMX.google.vpx.decoder" },
{ MEDIA_MIMETYPE_VIDEO_VPX, "VPXDecoder" },
{ MEDIA_MIMETYPE_VIDEO_MPEG2, "OMX.Nvidia.mpeg2v.decode" },
};
static const CodecInfo kEncoderInfo[] = {
@@ -534,6 +534,10 @@ sp<MediaSource> OMXCodec::Create(
err = codec->configureCodec(meta, flags);
if (err == OK) {
if (!strcmp("OMX.Nvidia.mpeg2v.decode", componentName)) {
codec->mOnlySubmitOneBufferAtOneTime = true;
}
return codec;
}
@@ -1357,6 +1361,8 @@ status_t OMXCodec::setVideoOutputFormat(
compressionFormat = OMX_VIDEO_CodingH263;
} else if (!strcasecmp(MEDIA_MIMETYPE_VIDEO_VPX, mime)) {
compressionFormat = OMX_VIDEO_CodingVPX;
} else if (!strcasecmp(MEDIA_MIMETYPE_VIDEO_MPEG2, mime)) {
compressionFormat = OMX_VIDEO_CodingMPEG2;
} else {
LOGE("Not a supported video mime type: %s", mime);
CHECK(!"Should not be here. Not a supported video mime type.");

3
media/libstagefright/VBRISeeker.cpp
View File

@@ -20,6 +20,7 @@
#include "include/VBRISeeker.h"
#include "include/avc_utils.h"
#include "include/MP3Extractor.h"
#include <media/stagefright/foundation/ADebug.h>
@@ -46,7 +47,7 @@ sp<VBRISeeker> VBRISeeker::CreateFromSource(
uint32_t tmp = U32_AT(&header[0]);
size_t frameSize;
int sampleRate;
if (!MP3Extractor::get_mp3_frame_size(tmp, &frameSize, &sampleRate)) {
if (!GetMPEGAudioFrameSize(tmp, &frameSize, &sampleRate)) {
return NULL;
}

231
media/libstagefright/avc_utils.cpp
View File

@@ -376,5 +376,236 @@ sp<MetaData> MakeAACCodecSpecificData(
return meta;
}
bool ExtractDimensionsFromVOLHeader(
const uint8_t *data, size_t size, int32_t *width, int32_t *height) {
ABitReader br(&data[4], size - 4);
br.skipBits(1); // random_accessible_vol
unsigned video_object_type_indication = br.getBits(8);
CHECK_NE(video_object_type_indication,
0x21u /* Fine Granularity Scalable */);
unsigned video_object_layer_verid;
unsigned video_object_layer_priority;
if (br.getBits(1)) {
video_object_layer_verid = br.getBits(4);
video_object_layer_priority = br.getBits(3);
}
unsigned aspect_ratio_info = br.getBits(4);
if (aspect_ratio_info == 0x0f /* extended PAR */) {
br.skipBits(8); // par_width
br.skipBits(8); // par_height
}
if (br.getBits(1)) { // vol_control_parameters
br.skipBits(2); // chroma_format
br.skipBits(1); // low_delay
if (br.getBits(1)) { // vbv_parameters
br.skipBits(15); // first_half_bit_rate
CHECK(br.getBits(1)); // marker_bit
br.skipBits(15); // latter_half_bit_rate
CHECK(br.getBits(1)); // marker_bit
br.skipBits(15); // first_half_vbv_buffer_size
CHECK(br.getBits(1)); // marker_bit
br.skipBits(3); // latter_half_vbv_buffer_size
br.skipBits(11); // first_half_vbv_occupancy
CHECK(br.getBits(1)); // marker_bit
br.skipBits(15); // latter_half_vbv_occupancy
CHECK(br.getBits(1)); // marker_bit
}
}
unsigned video_object_layer_shape = br.getBits(2);
CHECK_EQ(video_object_layer_shape, 0x00u /* rectangular */);
CHECK(br.getBits(1)); // marker_bit
unsigned vop_time_increment_resolution = br.getBits(16);
CHECK(br.getBits(1)); // marker_bit
if (br.getBits(1)) { // fixed_vop_rate
// range [0..vop_time_increment_resolution)
// vop_time_increment_resolution
// 2 => 0..1, 1 bit
// 3 => 0..2, 2 bits
// 4 => 0..3, 2 bits
// 5 => 0..4, 3 bits
// ...
CHECK_GT(vop_time_increment_resolution, 0u);
--vop_time_increment_resolution;
unsigned numBits = 0;
while (vop_time_increment_resolution > 0) {
++numBits;
vop_time_increment_resolution >>= 1;
}
br.skipBits(numBits); // fixed_vop_time_increment
}
CHECK(br.getBits(1)); // marker_bit
unsigned video_object_layer_width = br.getBits(13);
CHECK(br.getBits(1)); // marker_bit
unsigned video_object_layer_height = br.getBits(13);
CHECK(br.getBits(1)); // marker_bit
unsigned interlaced = br.getBits(1);
*width = video_object_layer_width;
*height = video_object_layer_height;
return true;
}
bool GetMPEGAudioFrameSize(
uint32_t header, size_t *frame_size,
int *out_sampling_rate, int *out_channels,
int *out_bitrate, int *out_num_samples) {
*frame_size = 0;
if (out_sampling_rate) {
*out_sampling_rate = 0;
}
if (out_channels) {
*out_channels = 0;
}
if (out_bitrate) {
*out_bitrate = 0;
}
if (out_num_samples) {
*out_num_samples = 1152;
}
if ((header & 0xffe00000) != 0xffe00000) {
return false;
}
unsigned version = (header >> 19) & 3;
if (version == 0x01) {
return false;
}
unsigned layer = (header >> 17) & 3;
if (layer == 0x00) {
return false;
}
unsigned protection = (header >> 16) & 1;
unsigned bitrate_index = (header >> 12) & 0x0f;
if (bitrate_index == 0 || bitrate_index == 0x0f) {
// Disallow "free" bitrate.
return false;
}
unsigned sampling_rate_index = (header >> 10) & 3;
if (sampling_rate_index == 3) {
return false;
}
static const int kSamplingRateV1[] = { 44100, 48000, 32000 };
int sampling_rate = kSamplingRateV1[sampling_rate_index];
if (version == 2 /* V2 */) {
sampling_rate /= 2;
} else if (version == 0 /* V2.5 */) {
sampling_rate /= 4;
}
unsigned padding = (header >> 9) & 1;
if (layer == 3) {
// layer I
static const int kBitrateV1[] = {
32, 64, 96, 128, 160, 192, 224, 256,
288, 320, 352, 384, 416, 448
};
static const int kBitrateV2[] = {
32, 48, 56, 64, 80, 96, 112, 128,
144, 160, 176, 192, 224, 256
};
int bitrate =
(version == 3 /* V1 */)
? kBitrateV1[bitrate_index - 1]
: kBitrateV2[bitrate_index - 1];
if (out_bitrate) {
*out_bitrate = bitrate;
}
*frame_size = (12000 * bitrate / sampling_rate + padding) * 4;
if (out_num_samples) {
*out_num_samples = 384;
}
} else {
// layer II or III
static const int kBitrateV1L2[] = {
32, 48, 56, 64, 80, 96, 112, 128,
160, 192, 224, 256, 320, 384
};
static const int kBitrateV1L3[] = {
32, 40, 48, 56, 64, 80, 96, 112,
128, 160, 192, 224, 256, 320
};
static const int kBitrateV2[] = {
8, 16, 24, 32, 40, 48, 56, 64,
80, 96, 112, 128, 144, 160
};
int bitrate;
if (version == 3 /* V1 */) {
bitrate = (layer == 2 /* L2 */)
? kBitrateV1L2[bitrate_index - 1]
: kBitrateV1L3[bitrate_index - 1];
if (out_num_samples) {
*out_num_samples = 1152;
}
} else {
// V2 (or 2.5)
bitrate = kBitrateV2[bitrate_index - 1];
if (out_num_samples) {
*out_num_samples = 576;
}
}
if (out_bitrate) {
*out_bitrate = bitrate;
}
if (version == 3 /* V1 */) {
*frame_size = 144000 * bitrate / sampling_rate + padding;
} else {
// V2 or V2.5
*frame_size = 72000 * bitrate / sampling_rate + padding;
}
}
if (out_sampling_rate) {
*out_sampling_rate = sampling_rate;
}
if (out_channels) {
int channel_mode = (header >> 6) & 3;
*out_channels = (channel_mode == 3) ? 1 : 2;
}
return true;
}
} // namespace android

1
media/libstagefright/codecs/mp3dec/SoftMP3.cpp
View File

@@ -223,6 +223,7 @@ void SoftMP3::onQueueFilled(OMX_U32 portIndex) {
if (decoderErr != NO_ENOUGH_MAIN_DATA_ERROR ||
mConfig->outputFrameSize == 0) {
LOGE("mp3 decoder returned error %d", decoderErr);
if (mConfig->outputFrameSize == 0) {
LOGE("Output frame size is 0");

5
media/libstagefright/include/MP3Extractor.h
View File

@@ -39,11 +39,6 @@ public:
virtual sp<MetaData> getMetaData();
static bool get_mp3_frame_size(
uint32_t header, size_t *frame_size,
int *out_sampling_rate = NULL, int *out_channels = NULL,
int *out_bitrate = NULL, int *out_num_samples = NULL);
private:
status_t mInitCheck;

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

@@ -57,6 +57,16 @@ sp<MetaData> MakeAACCodecSpecificData(
unsigned profile, unsigned sampling_freq_index,
unsigned channel_configuration);
// Given an MPEG4 video VOL-header chunk (starting with 0x00 0x00 0x01 0x2?)
// parse it and fill in dimensions, returns true iff successful.
bool ExtractDimensionsFromVOLHeader(
const uint8_t *data, size_t size, int32_t *width, int32_t *height);
bool GetMPEGAudioFrameSize(
uint32_t header, size_t *frame_size,
int *out_sampling_rate = NULL, int *out_channels = NULL,
int *out_bitrate = NULL, int *out_num_samples = NULL);
} // namespace android
#endif // AVC_UTILS_H_

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

@@ -44,7 +44,7 @@ namespace android {
static const size_t kTSPacketSize = 188;
struct ATSParser::Program : public RefBase {
Program(ATSParser *parser, unsigned programMapPID);
Program(ATSParser *parser, unsigned programNumber, unsigned programMapPID);
bool parsePID(
unsigned pid, unsigned payload_unit_start_indicator,
@@ -63,8 +63,15 @@ struct ATSParser::Program : public RefBase {
return mFirstPTSValid;
}
unsigned number() const { return mProgramNumber; }
void updateProgramMapPID(unsigned programMapPID) {
mProgramMapPID = programMapPID;
}
private:
ATSParser *mParser;
unsigned mProgramNumber;
unsigned mProgramMapPID;
KeyedVector<unsigned, sp<Stream> > mStreams;
bool mFirstPTSValid;
@@ -107,7 +114,7 @@ private:
DiscontinuityType mPendingDiscontinuity;
sp<AMessage> mPendingDiscontinuityExtra;
ElementaryStreamQueue mQueue;
ElementaryStreamQueue *mQueue;
void flush();
void parsePES(ABitReader *br);
@@ -126,11 +133,14 @@ private:
////////////////////////////////////////////////////////////////////////////////
ATSParser::Program::Program(ATSParser *parser, unsigned programMapPID)
ATSParser::Program::Program(
ATSParser *parser, unsigned programNumber, unsigned programMapPID)
: mParser(parser),
mProgramNumber(programNumber),
mProgramMapPID(programMapPID),
mFirstPTSValid(false),
mFirstPTS(0) {
LOGV("new program number %u", programNumber);
}
bool ATSParser::Program::parsePID(
@@ -299,7 +309,7 @@ void ATSParser::Program::parseProgramMap(ABitReader *br) {
}
sp<MediaSource> ATSParser::Program::getSource(SourceType type) {
size_t index = (type == MPEG2ADTS_AUDIO) ? 0 : 0;
size_t index = (type == AUDIO) ? 0 : 0;
for (size_t i = 0; i < mStreams.size(); ++i) {
sp<MediaSource> source = mStreams.editValueAt(i)->getSource(type);
@@ -338,14 +348,43 @@ ATSParser::Stream::Stream(
mBuffer(new ABuffer(192 * 1024)),
mPayloadStarted(false),
mPendingDiscontinuity(DISCONTINUITY_NONE),
mQueue(streamType == 0x1b
? ElementaryStreamQueue::H264 : ElementaryStreamQueue::AAC) {
mQueue(NULL) {
mBuffer->setRange(0, 0);
switch (mStreamType) {
case STREAMTYPE_H264:
mQueue = new ElementaryStreamQueue(ElementaryStreamQueue::H264);
break;
case STREAMTYPE_MPEG2_AUDIO_ATDS:
mQueue = new ElementaryStreamQueue(ElementaryStreamQueue::AAC);
break;
case STREAMTYPE_MPEG1_AUDIO:
case STREAMTYPE_MPEG2_AUDIO:
mQueue = new ElementaryStreamQueue(
ElementaryStreamQueue::MPEG_AUDIO);
break;
case STREAMTYPE_MPEG1_VIDEO:
case STREAMTYPE_MPEG2_VIDEO:
mQueue = new ElementaryStreamQueue(
ElementaryStreamQueue::MPEG_VIDEO);
break;
case STREAMTYPE_MPEG4_VIDEO:
mQueue = new ElementaryStreamQueue(
ElementaryStreamQueue::MPEG4_VIDEO);
break;
default:
break;
}
LOGV("new stream PID 0x%02x, type 0x%02x", elementaryPID, streamType);
}
ATSParser::Stream::~Stream() {
delete mQueue;
mQueue = NULL;
}
void ATSParser::Stream::parse(
@@ -397,7 +436,7 @@ void ATSParser::Stream::signalDiscontinuity(
{
bool isASeek = (type == DISCONTINUITY_SEEK);
mQueue.clear(!isASeek);
mQueue->clear(!isASeek);
uint64_t resumeAtPTS;
if (extra != NULL
@@ -444,6 +483,12 @@ void ATSParser::Stream::parsePES(ABitReader *br) {
LOGV("packet_startcode_prefix = 0x%08x", packet_startcode_prefix);
if (packet_startcode_prefix != 1) {
LOGV("Supposedly payload_unit_start=1 unit does not start "
"with startcode.");
return;
}
CHECK_EQ(packet_startcode_prefix, 0x000001u);
unsigned stream_id = br->getBits(8);
@@ -611,22 +656,28 @@ void ATSParser::Stream::onPayloadData(
const uint8_t *data, size_t size) {
LOGV("onPayloadData mStreamType=0x%02x", mStreamType);
if (mQueue == NULL) {
return;
}
CHECK(PTS_DTS_flags == 2 || PTS_DTS_flags == 3);
int64_t timeUs = mProgram->convertPTSToTimestamp(PTS);
status_t err = mQueue.appendData(data, size, timeUs);
status_t err = mQueue->appendData(data, size, timeUs);
if (err != OK) {
return;
}
sp<ABuffer> accessUnit;
while ((accessUnit = mQueue.dequeueAccessUnit()) != NULL) {
while ((accessUnit = mQueue->dequeueAccessUnit()) != NULL) {
if (mSource == NULL) {
sp<MetaData> meta = mQueue.getFormat();
sp<MetaData> meta = mQueue->getFormat();
if (meta != NULL) {
LOGV("created source!");
LOGV("Stream PID 0x%08x of type 0x%02x now has data.",
mElementaryPID, mStreamType);
mSource = new AnotherPacketSource(meta);
if (mPendingDiscontinuity != DISCONTINUITY_NONE) {
@@ -638,13 +689,13 @@ void ATSParser::Stream::onPayloadData(
mSource->queueAccessUnit(accessUnit);
}
} else if (mQueue.getFormat() != NULL) {
} else if (mQueue->getFormat() != NULL) {
// After a discontinuity we invalidate the queue's format
// and won't enqueue any access units to the source until
// the queue has reestablished the new format.
if (mSource->getFormat() == NULL) {
mSource->setFormat(mQueue.getFormat());
mSource->setFormat(mQueue->getFormat());
}
mSource->queueAccessUnit(accessUnit);
}
@@ -652,9 +703,30 @@ void ATSParser::Stream::onPayloadData(
}
sp<MediaSource> ATSParser::Stream::getSource(SourceType type) {
if ((type == AVC_VIDEO && mStreamType == 0x1b)
|| (type == MPEG2ADTS_AUDIO && mStreamType == 0x0f)) {
return mSource;
switch (type) {
case VIDEO:
{
if (mStreamType == STREAMTYPE_H264
|| mStreamType == STREAMTYPE_MPEG1_VIDEO
|| mStreamType == STREAMTYPE_MPEG2_VIDEO
|| mStreamType == STREAMTYPE_MPEG4_VIDEO) {
return mSource;
}
break;
}
case AUDIO:
{
if (mStreamType == STREAMTYPE_MPEG1_AUDIO
|| mStreamType == STREAMTYPE_MPEG2_AUDIO
|| mStreamType == STREAMTYPE_MPEG2_AUDIO_ATDS) {
return mSource;
}
break;
}
default:
break;
}
return NULL;
@@ -729,7 +801,21 @@ void ATSParser::parseProgramAssociationTable(ABitReader *br) {
LOGV(" program_map_PID = 0x%04x", programMapPID);
mPrograms.push(new Program(this, programMapPID));
bool found = false;
for (size_t index = 0; index < mPrograms.size(); ++index) {
const sp<Program> &program = mPrograms.itemAt(index);
if (program->number() == program_number) {
program->updateProgramMapPID(programMapPID);
found = true;
break;
}
}
if (!found) {
mPrograms.push(
new Program(this, program_number, programMapPID));
}
}
}
@@ -805,8 +891,16 @@ void ATSParser::parseTS(ABitReader *br) {
}
sp<MediaSource> ATSParser::getSource(SourceType type) {
int which = -1; // any
for (size_t i = 0; i < mPrograms.size(); ++i) {
sp<MediaSource> source = mPrograms.editItemAt(i)->getSource(type);
const sp<Program> &program = mPrograms.editItemAt(i);
if (which >= 0 && (int)program->number() != which) {
continue;
}
sp<MediaSource> source = program->getSource(type);
if (source != NULL) {
return source;

15
media/libstagefright/mpeg2ts/ATSParser.h
View File

@@ -48,8 +48,8 @@ struct ATSParser : public RefBase {
void signalEOS(status_t finalResult);
enum SourceType {
AVC_VIDEO,
MPEG2ADTS_AUDIO
VIDEO,
AUDIO
};
sp<MediaSource> getSource(SourceType type);
@@ -59,6 +59,17 @@ protected:
virtual ~ATSParser();
private:
enum {
// From ISO/IEC 13818-1: 2000 (E), Table 2-29
STREAMTYPE_MPEG1_VIDEO = 0x01,
STREAMTYPE_MPEG2_VIDEO = 0x02,
STREAMTYPE_MPEG1_AUDIO = 0x03,
STREAMTYPE_MPEG2_AUDIO = 0x04,
STREAMTYPE_MPEG2_AUDIO_ATDS = 0x0f,
STREAMTYPE_MPEG4_VIDEO = 0x10,
STREAMTYPE_H264 = 0x1b,
};
struct Program;
struct Stream;

485
media/libstagefright/mpeg2ts/ESQueue.cpp
View File

@@ -27,6 +27,7 @@
#include <media/stagefright/MediaErrors.h>
#include <media/stagefright/MediaDefs.h>
#include <media/stagefright/MetaData.h>
#include <media/stagefright/Utils.h>
#include "include/avc_utils.h"
@@ -79,11 +80,49 @@ static bool IsSeeminglyValidADTSHeader(const uint8_t *ptr, size_t size) {
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) {
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)) {
@@ -105,7 +144,40 @@ status_t ElementaryStreamQueue::appendData(
}
if (startOffset > 0) {
LOGI("found something resembling an H.264 syncword at "
LOGI("found something resembling an H.264/MPEG syncword at "
"offset %ld",
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) {
LOGI("found something resembling an H.264/MPEG syncword at "
"offset %ld",
startOffset);
}
@@ -148,6 +220,33 @@ status_t ElementaryStreamQueue::appendData(
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) {
LOGI("found something resembling an MPEG audio "
"syncword at offset %ld",
startOffset);
}
data = &ptr[startOffset];
size -= startOffset;
break;
}
default:
TRESPASS();
break;
@@ -190,11 +289,18 @@ status_t ElementaryStreamQueue::appendData(
}
sp<ABuffer> ElementaryStreamQueue::dequeueAccessUnit() {
if (mMode == H264) {
return dequeueAccessUnitH264();
} else {
CHECK_EQ((unsigned)mMode, (unsigned)AAC);
return dequeueAccessUnitAAC();
switch (mMode) {
case H264:
return dequeueAccessUnitH264();
case AAC:
return dequeueAccessUnitAAC();
case MPEG_VIDEO:
return dequeueAccessUnitMPEGVideo();
case MPEG4_VIDEO:
return dequeueAccessUnitMPEG4Video();
default:
CHECK_EQ((unsigned)mMode, (unsigned)MPEG_AUDIO);
return dequeueAccessUnitMPEGAudio();
}
}
@@ -455,4 +561,371 @@ sp<ABuffer> ElementaryStreamQueue::dequeueAccessUnitH264() {
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;
CHECK(GetMPEGAudioFrameSize(
header, &frameSize, &samplingRate, &numChannels,
&bitrate, &numSamples));
if (size < frameSize) {
return NULL;
}
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);
CHECK_GE(timeUs, 0ll);
accessUnit->meta()->setInt64("timeUs", timeUs);
if (mFormat == NULL) {
mFormat = new MetaData;
mFormat->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_MPEG);
mFormat->setInt32(kKeySampleRate, samplingRate);
mFormat->setInt32(kKeyChannelCount, numChannels);
}
return accessUnit;
}
static void EncodeSize14(uint8_t **_ptr, size_t size) {
CHECK_LE(size, 0x3fff);
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() {
const uint8_t *data = mBuffer->data();
size_t size = mBuffer->size();
bool sawPictureStart = false;
int pprevStartCode = -1;
int prevStartCode = -1;
int currentStartCode = -1;
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) {
CHECK_GE(size, 7u);
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);
LOGI("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 == 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);
CHECK_GE(timeUs, 0ll);
offset = 0;
accessUnit->meta()->setInt64("timeUs", timeUs);
LOGV("returning MPEG video access unit at time %lld us",
timeUs);
// hexdump(accessUnit->data(), accessUnit->size());
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)) {
TRESPASS();
}
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:
{
CHECK_EQ(chunkType, 0xb5);
state = EXPECT_VO_START;
break;
}
case EXPECT_VO_START:
{
CHECK_LE(chunkType, 0x1f);
state = EXPECT_VOL_START;
break;
}
case EXPECT_VOL_START:
{
CHECK((chunkType & 0xf0) == 0x20);
CHECK(ExtractDimensionsFromVOLHeader(
&data[offset], chunkSize,
&width, &height));
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);
LOGI("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) {
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);
CHECK_GE(timeUs, 0ll);
offset = 0;
accessUnit->meta()->setInt64("timeUs", timeUs);
LOGV("returning MPEG4 video access unit at time %lld us",
timeUs);
// hexdump(accessUnit->data(), accessUnit->size());
return accessUnit;
} else if (chunkType != 0xb3) {
offset += chunkSize;
discard = true;
}
break;
}
default:
TRESPASS();
}
if (discard) {
(void)fetchTimestamp(offset);
memmove(data, &data[offset], size - offset);
size -= offset;
offset = 0;
mBuffer->setRange(0, size);
} else {
offset += chunkSize;
}
}
return NULL;
}
} // namespace android

8
media/libstagefright/mpeg2ts/ESQueue.h
View File

@@ -31,7 +31,10 @@ struct MetaData;
struct ElementaryStreamQueue {
enum Mode {
H264,
AAC
AAC,
MPEG_AUDIO,
MPEG_VIDEO,
MPEG4_VIDEO,
};
ElementaryStreamQueue(Mode mode);
@@ -57,6 +60,9 @@ private:
sp<ABuffer> dequeueAccessUnitH264();
sp<ABuffer> dequeueAccessUnitAAC();
sp<ABuffer> dequeueAccessUnitMPEGAudio();
sp<ABuffer> dequeueAccessUnitMPEGVideo();
sp<ABuffer> dequeueAccessUnitMPEG4Video();
// consume a logical (compressed) access unit of size "size",
// returns its timestamp in us (or -1 if no time information).

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

@@ -175,7 +175,7 @@ void MPEG2TSExtractor::init() {
if (!haveVideo) {
sp<AnotherPacketSource> impl =
(AnotherPacketSource *)mParser->getSource(
ATSParser::AVC_VIDEO).get();
ATSParser::VIDEO).get();
if (impl != NULL) {
haveVideo = true;
@@ -186,7 +186,7 @@ void MPEG2TSExtractor::init() {
if (!haveAudio) {
sp<AnotherPacketSource> impl =
(AnotherPacketSource *)mParser->getSource(
ATSParser::MPEG2ADTS_AUDIO).get();
ATSParser::AUDIO).get();
if (impl != NULL) {
haveAudio = true;
@@ -194,7 +194,7 @@ void MPEG2TSExtractor::init() {
}
}
if (++numPacketsParsed > 2500) {
if (++numPacketsParsed > 10000) {
break;
}
}

88
media/libstagefright/rtsp/APacketSource.cpp
View File

@@ -329,7 +329,7 @@ static uint8_t *EncodeSize(uint8_t *dst, size_t x) {
return dst;
}
static bool ExtractDimensionsFromVOLHeader(
static bool ExtractDimensionsMPEG4Config(
const sp<ABuffer> &config, int32_t *width, int32_t *height) {
*width = 0;
*height = 0;
@@ -352,87 +352,11 @@ static bool ExtractDimensionsFromVOLHeader(
return false;
}
ABitReader br(&ptr[offset + 4], config->size() - offset - 4);
br.skipBits(1); // random_accessible_vol
unsigned video_object_type_indication = br.getBits(8);
CHECK_NE(video_object_type_indication,
0x21u /* Fine Granularity Scalable */);
unsigned video_object_layer_verid;
unsigned video_object_layer_priority;
if (br.getBits(1)) {
video_object_layer_verid = br.getBits(4);
video_object_layer_priority = br.getBits(3);
}
unsigned aspect_ratio_info = br.getBits(4);
if (aspect_ratio_info == 0x0f /* extended PAR */) {
br.skipBits(8); // par_width
br.skipBits(8); // par_height
}
if (br.getBits(1)) { // vol_control_parameters
br.skipBits(2); // chroma_format
br.skipBits(1); // low_delay
if (br.getBits(1)) { // vbv_parameters
br.skipBits(15); // first_half_bit_rate
CHECK(br.getBits(1)); // marker_bit
br.skipBits(15); // latter_half_bit_rate
CHECK(br.getBits(1)); // marker_bit
br.skipBits(15); // first_half_vbv_buffer_size
CHECK(br.getBits(1)); // marker_bit
br.skipBits(3); // latter_half_vbv_buffer_size
br.skipBits(11); // first_half_vbv_occupancy
CHECK(br.getBits(1)); // marker_bit
br.skipBits(15); // latter_half_vbv_occupancy
CHECK(br.getBits(1)); // marker_bit
}
}
unsigned video_object_layer_shape = br.getBits(2);
CHECK_EQ(video_object_layer_shape, 0x00u /* rectangular */);
CHECK(br.getBits(1)); // marker_bit
unsigned vop_time_increment_resolution = br.getBits(16);
CHECK(br.getBits(1)); // marker_bit
if (br.getBits(1)) { // fixed_vop_rate
// range [0..vop_time_increment_resolution)
// vop_time_increment_resolution
// 2 => 0..1, 1 bit
// 3 => 0..2, 2 bits
// 4 => 0..3, 2 bits
// 5 => 0..4, 3 bits
// ...
CHECK_GT(vop_time_increment_resolution, 0u);
--vop_time_increment_resolution;
unsigned numBits = 0;
while (vop_time_increment_resolution > 0) {
++numBits;
vop_time_increment_resolution >>= 1;
}
br.skipBits(numBits); // fixed_vop_time_increment
}
CHECK(br.getBits(1)); // marker_bit
unsigned video_object_layer_width = br.getBits(13);
CHECK(br.getBits(1)); // marker_bit
unsigned video_object_layer_height = br.getBits(13);
CHECK(br.getBits(1)); // marker_bit
unsigned interlaced = br.getBits(1);
*width = video_object_layer_width;
*height = video_object_layer_height;
LOGI("VOL dimensions = %dx%d", *width, *height);
return true;
return ExtractDimensionsFromVOLHeader(
&ptr[offset], config->size() - offset, width, height);
}
sp<ABuffer> MakeMPEG4VideoCodecSpecificData(
static sp<ABuffer> MakeMPEG4VideoCodecSpecificData(
const char *params, int32_t *width, int32_t *height) {
*width = 0;
*height = 0;
@@ -443,10 +367,12 @@ sp<ABuffer> MakeMPEG4VideoCodecSpecificData(
sp<ABuffer> config = decodeHex(val);
CHECK(config != NULL);
if (!ExtractDimensionsFromVOLHeader(config, width, height)) {
if (!ExtractDimensionsMPEG4Config(config, width, height)) {
return NULL;
}
LOGI("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;