void
MP4AudioInfo::Update(const MetaData* aMetaData,
const char* aMimeType)
{
UpdateTrackInfo(*this, aMetaData, aMimeType);
mChannels = FindInt32(aMetaData, kKeyChannelCount);
mBitDepth = FindInt32(aMetaData, kKeySampleSize);
mRate = FindInt32(aMetaData, kKeySampleRate);
mProfile = FindInt32(aMetaData, kKeyAACProfile);
if (FindData(aMetaData, kKeyESDS, mExtraData)) {
ESDS esds(mExtraData->Elements(), mExtraData->Length());
const void* data;
size_t size;
if (esds.getCodecSpecificInfo(&data, &size) == OK) {
const uint8_t* cdata = reinterpret_cast<const uint8_t*>(data);
mCodecSpecificConfig->AppendElements(cdata, size);
if (size > 1) {
ABitReader br(cdata, size);
mExtendedProfile = br.getBits(5);
if (mExtendedProfile == 31) { // AAC-ELD => additional 6 bits
mExtendedProfile = 32 + br.getBits(6);
}
}
}
}
}
void
MP4VideoInfo::Update(const MetaData* aMetaData, const char* aMimeType)
{
UpdateTrackInfo(*this, aMetaData, aMimeType);
mDisplay.width = FindInt32(aMetaData, kKeyDisplayWidth);
mDisplay.height = FindInt32(aMetaData, kKeyDisplayHeight);
mImage.width = FindInt32(aMetaData, kKeyWidth);
mImage.height = FindInt32(aMetaData, kKeyHeight);
mRotation = VideoInfo::ToSupportedRotation(FindInt32(aMetaData, kKeyRotation));
FindData(aMetaData, kKeyAVCC, mExtraData);
if (!mExtraData->Length()) {
if (FindData(aMetaData, kKeyESDS, mExtraData)) {
ESDS esds(mExtraData->Elements(), mExtraData->Length());
const void* data;
size_t size;
if (esds.getCodecSpecificInfo(&data, &size) == OK) {
const uint8_t* cdata = reinterpret_cast<const uint8_t*>(data);
mCodecSpecificConfig->AppendElements(cdata, size);
}
}
}
}
void
AudioDecoderConfig::Update(sp<MetaData>& aMetaData, const char* aMimeType)
{
TrackConfig::Update(aMetaData, aMimeType);
channel_count = FindInt32(aMetaData, kKeyChannelCount);
bits_per_sample = FindInt32(aMetaData, kKeySampleSize);
samples_per_second = FindInt32(aMetaData, kKeySampleRate);
frequency_index = Adts::GetFrequencyIndex(samples_per_second);
aac_profile = FindInt32(aMetaData, kKeyAACProfile);
if (FindData(aMetaData, kKeyESDS, extra_data)) {
ESDS esds(extra_data->Elements(), extra_data->Length());
const void* data;
size_t size;
if (esds.getCodecSpecificInfo(&data, &size) == OK) {
const uint8_t* cdata = reinterpret_cast<const uint8_t*>(data);
audio_specific_config->AppendElements(cdata, size);
if (size > 1) {
ABitReader br(cdata, size);
extended_profile = br.getBits(5);
if (extended_profile == 31) { // AAC-ELD => additional 6 bits
extended_profile = 32 + br.getBits(6);
}
}
}
}
}
void
MP4VideoInfo::Update(const MetaData* aMetaData, const char* aMimeType)
{
UpdateTrackInfo(*this, aMetaData, aMimeType);
mDisplay.width = FindInt32(aMetaData, kKeyDisplayWidth);
mDisplay.height = FindInt32(aMetaData, kKeyDisplayHeight);
mImage.width = FindInt32(aMetaData, kKeyWidth);
mImage.height = FindInt32(aMetaData, kKeyHeight);
FindData(aMetaData, kKeyAVCC, mExtraData);
}
void
VideoDecoderConfig::Update(sp<MetaData>& aMetaData, const char* aMimeType)
{
TrackConfig::Update(aMetaData, aMimeType);
display_width = FindInt32(aMetaData, kKeyDisplayWidth);
display_height = FindInt32(aMetaData, kKeyDisplayHeight);
image_width = FindInt32(aMetaData, kKeyWidth);
image_height = FindInt32(aMetaData, kKeyHeight);
FindData(aMetaData, kKeyAVCC, extra_data);
}
int32
PSettings::GetInt32(const char *name)
{
int32 val=0;
FindInt32(name,&val);
return val;
}
void
VideoDecoderConfig::Update(sp<MetaData>& aMetaData, const char* aMimeType)
{
TrackConfig::Update(aMetaData, aMimeType);
display_width = FindInt32(aMetaData, kKeyDisplayWidth);
display_height = FindInt32(aMetaData, kKeyDisplayHeight);
image_width = FindInt32(aMetaData, kKeyWidth);
image_height = FindInt32(aMetaData, kKeyHeight);
if (FindData(aMetaData, kKeyAVCC, &extra_data) && extra_data.length() >= 7) {
// Set size of the NAL length to 4. The demuxer formats its output with
// this NAL length size.
extra_data[4] |= 3;
annex_b = AnnexB::ConvertExtraDataToAnnexB(extra_data);
}
}
int32
PSettings::GetInt32(const char *name,int32 def)
{
int32 val=0;
if(FindInt32(name,&val)==B_OK)return val;
else
return def;
}
uint32
AttributeMessage::GetAttribute(const char* name, uint32 defaultValue) const
{
int32 value;
if (FindInt32(name, &value) != B_OK)
return defaultValue;
return (uint32)value;
}
void
PSettings::SetInt32(const char *name,int32 value)
{
int32 old;
status_t s=FindInt32(name,&old);
if(s==B_OK)ReplaceInt32(name,value);
else AddInt32(name,value);
}
int Config::GetInt(const char *name, const int Default)
{
int32 value;
if (FindInt32(name, &value) == B_OK)
return value;
else
return Default;
}
myinline int32 ArpMessage::GetInt32(const char *name, int32 def, int32 index) const
{
if( this ) {
int32 res;
if( FindInt32(name, index, &res) != B_NO_ERROR ) return def;
return res;
}
return def;
}
//------------------------------------------------------------------------------
status_t TTextData::Unarchive(const BMessage& oArc)
{
status_t aResult = B_OK;
aResult |= SUPER::Unarchive(oArc);
// bool
aResult |= FindBool(oArc, ARC_NAME_EXPAND, &mExpand);
aResult |= FindBool(oArc, ARC_NAME_GROUP, &mGroup);
aResult |= FindBool(oArc, ARC_NAME_PATTERN_MATCH, &mPatternMatch);
// int32
aResult |= FindInt32(oArc, ARC_NAME_ID, &mID);
// uint32
aResult |= FindInt32(oArc, ARC_NAME_OUTLINE_LEVEL, reinterpret_cast<int32*>(&mOutlineLevel));
// string
aResult |= FindString(oArc, ARC_NAME_TITLE, &mTitle);
// Message
aResult |= FindMessage(oArc, ARC_NAME_DATA, &mData);
return aResult;
}
void
TrackConfig::Update(sp<MetaData>& aMetaData, const char* aMimeType)
{
// aMimeType points to a string from MediaDefs.cpp so we don't need to copy it
mime_type = aMimeType;
duration = FindInt64(aMetaData, kKeyDuration);
media_time = FindInt64(aMetaData, kKeyMediaTime);
mTrackId = FindInt32(aMetaData, kKeyTrackID);
crypto.Update(aMetaData);
}
bool
Preferences::ReadInt32(int32 &val, const char* name)
{
Lock();
int32 readVal;
bool found = FindInt32(name, &readVal) == B_OK;
if (found)
val = readVal;
Unlock();
return found;
}
static void
UpdateTrackInfo(mozilla::TrackInfo& aConfig,
const MetaData* aMetaData,
const char* aMimeType)
{
mozilla::CryptoTrack& crypto = aConfig.mCrypto;
aConfig.mMimeType = aMimeType;
aConfig.mDuration = FindInt64(aMetaData, kKeyDuration);
aConfig.mMediaTime = FindInt64(aMetaData, kKeyMediaTime);
aConfig.mTrackId = FindInt32(aMetaData, kKeyTrackID);
aConfig.mCrypto.mValid = aMetaData->findInt32(kKeyCryptoMode, &crypto.mMode) &&
aMetaData->findInt32(kKeyCryptoDefaultIVSize, &crypto.mIVSize) &&
FindData(aMetaData, kKeyCryptoKey, &crypto.mKeyId);
}
void
MP4Sample::Update(int64_t& aMediaTime)
{
sp<MetaData> m = mMediaBuffer->meta_data();
decode_timestamp = FindInt64(m, kKeyDecodingTime);
composition_timestamp = FindInt64(m, kKeyTime) - aMediaTime;
duration = FindInt64(m, kKeyDuration);
byte_offset = FindInt64(m, kKey64BitFileOffset);
is_sync_point = FindInt32(m, kKeyIsSyncFrame);
data = reinterpret_cast<uint8_t*>(mMediaBuffer->data());
size = mMediaBuffer->range_length();
crypto.Update(m);
}
void
MP4Sample::Update(int64_t& aMediaTime)
{
sp<MetaData> m = mMediaBuffer->meta_data();
// XXXbholley - Why don't we adjust decode_timestamp for aMediaTime?
// According to k17e, this code path is no longer used - we should probably remove it.
decode_timestamp = FindInt64(m, kKeyDecodingTime);
composition_timestamp = FindInt64(m, kKeyTime) - aMediaTime;
duration = FindInt64(m, kKeyDuration);
byte_offset = FindInt64(m, kKey64BitFileOffset);
is_sync_point = FindInt32(m, kKeyIsSyncFrame);
data = reinterpret_cast<uint8_t*>(mMediaBuffer->data());
size = mMediaBuffer->range_length();
crypto.Update(m);
}
int32 Message::FindInt32(const char *name, int32 *anInt32) const
{
return FindInt32( name, 0, anInt32);
}
