steve
/
winamp
mirror of https://github.com/WinampDesktop/winamp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
winamp/Src/external_dependencies/libmp4v2/mp4property.cpp

734 lines
17 KiB
C++
Raw Blame History

/*
* The contents of this file are subject to the Mozilla Public
* License Version 1.1 (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.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
* implied. See the License for the specific language governing
* rights and limitations under the License.
*
* The Original Code is MPEG4IP.
*
* The Initial Developer of the Original Code is Cisco Systems Inc.
* Portions created by Cisco Systems Inc. are
* Copyright (C) Cisco Systems Inc. 2001. All Rights Reserved.
*
* Contributor(s):
* Dave Mackie dmackie@cisco.com
*/
#include "mp4common.h"
MP4Property::MP4Property(const char* name)
{
m_name = name;
m_pParentAtom = NULL;
m_readOnly = false;
m_implicit = false;
}
bool MP4Property::FindProperty(const char* name,
MP4Property** ppProperty, u_int32_t* pIndex)
{
if (name == NULL) {
return false;
}
if (!strcasecmp(m_name, name)) {
if (m_pParentAtom) {
VERBOSE_FIND(m_pParentAtom->GetFile()->GetVerbosity(),
printf("FindProperty: matched %s\n", name));
}
*ppProperty = this;
return true;
}
return false;
}
// Integer Property
u_int64_t MP4IntegerProperty::GetValue(u_int32_t index)
{
switch (this->GetType()) {
case Integer8Property:
return ((MP4Integer8Property*)this)->GetValue(index);
case Integer16Property:
return ((MP4Integer16Property*)this)->GetValue(index);
case Integer24Property:
return ((MP4Integer24Property*)this)->GetValue(index);
case Integer32Property:
return ((MP4Integer32Property*)this)->GetValue(index);
case Integer64Property:
return ((MP4Integer64Property*)this)->GetValue(index);
default:
ASSERT(FALSE);
}
return (0);
}
void MP4IntegerProperty::SetValue(u_int64_t value, u_int32_t index)
{
switch (this->GetType()) {
case Integer8Property:
((MP4Integer8Property*)this)->SetValue(value, index);
break;
case Integer16Property:
((MP4Integer16Property*)this)->SetValue(value, index);
break;
case Integer24Property:
((MP4Integer24Property*)this)->SetValue(value, index);
break;
case Integer32Property:
((MP4Integer32Property*)this)->SetValue(value, index);
break;
case Integer64Property:
((MP4Integer64Property*)this)->SetValue(value, index);
break;
default:
ASSERT(FALSE);
}
}
void MP4IntegerProperty::InsertValue(u_int64_t value, u_int32_t index)
{
switch (this->GetType()) {
case Integer8Property:
((MP4Integer8Property*)this)->InsertValue(value, index);
break;
case Integer16Property:
((MP4Integer16Property*)this)->InsertValue(value, index);
break;
case Integer24Property:
((MP4Integer24Property*)this)->InsertValue(value, index);
break;
case Integer32Property:
((MP4Integer32Property*)this)->InsertValue(value, index);
break;
case Integer64Property:
((MP4Integer64Property*)this)->InsertValue(value, index);
break;
default:
ASSERT(FALSE);
}
}
void MP4IntegerProperty::DeleteValue(u_int32_t index)
{
switch (this->GetType()) {
case Integer8Property:
((MP4Integer8Property*)this)->DeleteValue(index);
break;
case Integer16Property:
((MP4Integer16Property*)this)->DeleteValue(index);
break;
case Integer24Property:
((MP4Integer24Property*)this)->DeleteValue(index);
break;
case Integer32Property:
((MP4Integer32Property*)this)->DeleteValue(index);
break;
case Integer64Property:
((MP4Integer64Property*)this)->DeleteValue(index);
break;
default:
ASSERT(FALSE);
}
}
void MP4IntegerProperty::IncrementValue(int32_t increment, u_int32_t index)
{
SetValue(GetValue() + increment);
}
// MP4BitfieldProperty
void MP4BitfieldProperty::Read(MP4File* pFile, u_int32_t index)
{
if (m_implicit) {
return;
}
m_values[index] = pFile->ReadBits(m_numBits);
}
void MP4BitfieldProperty::Write(MP4File* pFile, u_int32_t index)
{
if (m_implicit) {
return;
}
pFile->WriteBits(m_values[index], m_numBits);
}
// MP4Float32Property
void MP4Float32Property::Read(MP4File* pFile, u_int32_t index)
{
if (m_implicit) {
return;
}
if (m_useFixed16Format) {
m_values[index] = pFile->ReadFixed16();
} else if (m_useFixed32Format) {
m_values[index] = pFile->ReadFixed32();
} else {
m_values[index] = pFile->ReadFloat();
}
}
void MP4Float32Property::Write(MP4File* pFile, u_int32_t index)
{
if (m_implicit) {
return;
}
if (m_useFixed16Format) {
pFile->WriteFixed16(m_values[index]);
} else if (m_useFixed32Format) {
pFile->WriteFixed32(m_values[index]);
} else {
pFile->WriteFloat(m_values[index]);
}
}
// MP4StringProperty
MP4StringProperty::MP4StringProperty(char* name,
bool useCountedFormat, bool useUnicode)
: MP4Property(name)
{
SetCount(1);
m_values[0] = NULL;
m_useCountedFormat = useCountedFormat;
m_useExpandedCount = false;
m_useUnicode = useUnicode;
m_fixedLength = 0; // length not fixed
}
MP4StringProperty::~MP4StringProperty()
{
u_int32_t count = GetCount();
for (u_int32_t i = 0; i < count; i++) {
MP4Free(m_values[i]);
}
}
void MP4StringProperty::SetCount(u_int32_t count)
{
u_int32_t oldCount = m_values.Size();
m_values.Resize(count);
for (u_int32_t i = oldCount; i < count; i++) {
m_values[i] = NULL;
}
}
void MP4StringProperty::SetValue(const char* value, u_int32_t index)
{
if (m_readOnly) {
throw new MP4Error(EACCES, "property is read-only", m_name);
}
MP4Free(m_values[index]);
if (m_fixedLength) {
m_values[index] = (char*)MP4Calloc(m_fixedLength + 1);
if (value) {
strncpy(m_values[index], value, m_fixedLength);
}
} else {
if (value) {
if (m_useUnicode)
m_values[index] = (char *)MP4Stralloc((const uint16_t *)value);
else
m_values[index] = MP4Stralloc(value);
} else {
m_values[index] = NULL;
}
}
}
void MP4StringProperty::Read(MP4File* pFile, u_int32_t index)
{
if (m_implicit) {
return;
}
if (m_useCountedFormat) {
m_values[index] = pFile->ReadCountedString(
(m_useUnicode ? 2 : 1), m_useExpandedCount);
} else if (m_fixedLength) {
MP4Free(m_values[index]);
m_values[index] = (char*)MP4Calloc(m_fixedLength + 1);
pFile->ReadBytes((u_int8_t*)m_values[index], m_fixedLength);
} else {
if (m_useUnicode)
{
m_values[index] = (char *)pFile->ReadUnicodeString();
}
else
{
char *str = pFile->ReadString();
if (str && str[0] == 0xFF && str[1] == 0xFE)
m_useUnicode = true;
if (str && str[0] == 0xFE && str[1] == 0xFF)
m_useUnicode = true;
m_values[index] = str;
}
}
}
void MP4StringProperty::Write(MP4File* pFile, u_int32_t index)
{
if (m_implicit) {
return;
}
if (m_useCountedFormat) {
pFile->WriteCountedString(m_values[index],
(m_useUnicode ? 2 : 1), m_useExpandedCount);
} else if (m_fixedLength) {
pFile->WriteBytes((u_int8_t*)m_values[index], m_fixedLength);
} else {
if (m_useUnicode)
pFile->WriteUnicodeString((const uint16_t *)m_values[index]);
else
pFile->WriteString(m_values[index]);
}
}
// MP4BytesProperty
MP4BytesProperty::MP4BytesProperty(char* name, u_int32_t valueSize,
u_int32_t defaultValueSize)
: MP4Property(name)
{
SetCount(1);
m_values[0] = (u_int8_t*)MP4Calloc(valueSize);
m_valueSizes[0] = valueSize;
m_fixedValueSize = 0;
m_defaultValueSize = defaultValueSize;
}
MP4BytesProperty::~MP4BytesProperty()
{
u_int32_t count = GetCount();
for (u_int32_t i = 0; i < count; i++) {
MP4Free(m_values[i]);
}
}
void MP4BytesProperty::SetCount(u_int32_t count)
{
u_int32_t oldCount = m_values.Size();
m_values.Resize(count);
m_valueSizes.Resize(count);
for (u_int32_t i = oldCount; i < count; i++) {
m_values[i] = NULL;
m_valueSizes[i] = m_defaultValueSize;
}
}
void MP4BytesProperty::SetValue(const u_int8_t* pValue, u_int32_t valueSize,
u_int32_t index)
{
if (m_readOnly) {
throw new MP4Error(EACCES, "property is read-only", m_name);
}
if (m_fixedValueSize) {
if (valueSize > m_fixedValueSize) {
throw new MP4Error("%s.%s value size %d exceeds fixed value size %d",
"MP4BytesProperty::SetValue",
GetParentAtom()->GetType(),
GetName(),
valueSize,
m_fixedValueSize);
}
if (m_values[index] == NULL) {
m_values[index] = (u_int8_t*)MP4Calloc(m_fixedValueSize);
m_valueSizes[index] = m_fixedValueSize;
}
if (pValue) {
memcpy(m_values[index], pValue, valueSize);
}
} else {
MP4Free(m_values[index]);
if (pValue) {
m_values[index] = (u_int8_t*)MP4Malloc(valueSize);
memcpy(m_values[index], pValue, valueSize);
m_valueSizes[index] = valueSize;
} else {
m_values[index] = NULL;
m_valueSizes[index] = 0;
}
}
}
void MP4BytesProperty::SetValueSize(u_int32_t valueSize, u_int32_t index)
{
if (m_fixedValueSize) {
throw new MP4Error("can't change size of fixed sized property",
"MP4BytesProperty::SetValueSize");
}
if (m_values[index] != NULL) {
m_values[index] = (u_int8_t*)MP4Realloc(m_values[index], valueSize);
}
m_valueSizes[index] = valueSize;
}
void MP4BytesProperty::SetFixedSize(u_int32_t fixedSize)
{
m_fixedValueSize = 0;
for (u_int32_t i = 0; i < GetCount(); i++) {
SetValueSize(fixedSize, i);
}
m_fixedValueSize = fixedSize;
}
void MP4BytesProperty::Read(MP4File* pFile, u_int32_t index)
{
if (m_implicit) {
return;
}
MP4Free(m_values[index]);
m_values[index] = (u_int8_t*)MP4Malloc(m_valueSizes[index]);
pFile->ReadBytes(m_values[index], m_valueSizes[index]);
}
void MP4BytesProperty::Write(MP4File* pFile, u_int32_t index)
{
if (m_implicit) {
return;
}
pFile->WriteBytes(m_values[index], m_valueSizes[index]);
}
// MP4TableProperty
MP4TableProperty::MP4TableProperty(char* name, MP4IntegerProperty* pCountProperty)
: MP4Property(name)
{
m_pCountProperty = pCountProperty;
m_pCountProperty->SetReadOnly();
}
MP4TableProperty::~MP4TableProperty()
{
for (u_int32_t i = 0; i < m_pProperties.Size(); i++) {
delete m_pProperties[i];
}
}
void MP4TableProperty::AddProperty(MP4Property* pProperty)
{
ASSERT(pProperty);
ASSERT(pProperty->GetType() != TableProperty);
ASSERT(pProperty->GetType() != DescriptorProperty);
m_pProperties.Add(pProperty);
pProperty->SetParentAtom(m_pParentAtom);
pProperty->SetCount(0);
}
bool MP4TableProperty::FindProperty(const char *name,
MP4Property** ppProperty, u_int32_t* pIndex)
{
ASSERT(m_name);
// check if first component of name matches ourselves
if (!MP4NameFirstMatches(m_name, name)) {
return false;
}
// check if the specified table entry exists
u_int32_t index;
bool haveIndex = MP4NameFirstIndex(name, &index);
if (haveIndex) {
if (index >= GetCount()) {
return false;
}
if (pIndex) {
*pIndex = index;
}
}
VERBOSE_FIND(m_pParentAtom->GetFile()->GetVerbosity(),
printf("FindProperty: matched %s\n", name));
// get name of table property
const char *tablePropName = MP4NameAfterFirst(name);
if (tablePropName == NULL) {
if (!haveIndex) {
*ppProperty = this;
return true;
}
return false;
}
// check if this table property exists
return FindContainedProperty(tablePropName, ppProperty, pIndex);
}
bool MP4TableProperty::FindContainedProperty(const char *name,
MP4Property** ppProperty, u_int32_t* pIndex)
{
u_int32_t numProperties = m_pProperties.Size();
for (u_int32_t i = 0; i < numProperties; i++) {
if (m_pProperties[i]->FindProperty(name, ppProperty, pIndex)) {
return true;
}
}
return false;
}
void MP4TableProperty::Read(MP4File* pFile, u_int32_t index)
{
ASSERT(index == 0);
if (m_implicit) {
return;
}
u_int32_t numProperties = m_pProperties.Size();
if (numProperties == 0) {
WARNING(numProperties == 0);
return;
}
u_int32_t numEntries = GetCount();
/* for each property set size */
for (u_int32_t j = 0; j < numProperties; j++) {
m_pProperties[j]->SetCount(numEntries);
}
for (u_int32_t i = 0; i < numEntries; i++) {
ReadEntry(pFile, i);
}
}
void MP4TableProperty::ReadEntry(MP4File* pFile, u_int32_t index)
{
for (u_int32_t j = 0; j < m_pProperties.Size(); j++) {
m_pProperties[j]->Read(pFile, index);
}
}
void MP4TableProperty::Write(MP4File* pFile, u_int32_t index)
{
ASSERT(index == 0);
if (m_implicit) {
return;
}
u_int32_t numProperties = m_pProperties.Size();
if (numProperties == 0) {
WARNING(numProperties == 0);
return;
}
u_int32_t numEntries = GetCount();
if (m_pProperties[0]->GetCount() != numEntries) {
fprintf(stderr, "%s %s \"%s\"table entries %u doesn't match count %u\n",
GetParentAtom() != NULL ? GetParentAtom()->GetType() : "",
GetName(), m_pProperties[0]->GetName(),
m_pProperties[0]->GetCount(), numEntries);
ASSERT(m_pProperties[0]->GetCount() == numEntries);
}
for (u_int32_t i = 0; i < numEntries; i++) {
WriteEntry(pFile, i);
}
}
void MP4TableProperty::WriteEntry(MP4File* pFile, u_int32_t index)
{
for (u_int32_t j = 0; j < m_pProperties.Size(); j++) {
m_pProperties[j]->Write(pFile, index);
}
}
// MP4DescriptorProperty
MP4DescriptorProperty::MP4DescriptorProperty(char* name,
u_int8_t tagsStart, u_int8_t tagsEnd, bool mandatory, bool onlyOne)
: MP4Property(name)
{
SetTags(tagsStart, tagsEnd);
m_sizeLimit = 0;
m_mandatory = mandatory;
m_onlyOne = onlyOne;
}
MP4DescriptorProperty::~MP4DescriptorProperty()
{
for (u_int32_t i = 0; i < m_pDescriptors.Size(); i++) {
delete m_pDescriptors[i];
}
}
void MP4DescriptorProperty::SetParentAtom(MP4Atom* pParentAtom) {
m_pParentAtom = pParentAtom;
for (u_int32_t i = 0; i < m_pDescriptors.Size(); i++) {
m_pDescriptors[i]->SetParentAtom(pParentAtom);
}
}
MP4Descriptor* MP4DescriptorProperty::AddDescriptor(u_int8_t tag)
{
// check that tag is in expected range
ASSERT(tag >= m_tagsStart && tag <= m_tagsEnd);
MP4Descriptor* pDescriptor = CreateDescriptor(tag);
ASSERT(pDescriptor);
m_pDescriptors.Add(pDescriptor);
pDescriptor->SetParentAtom(m_pParentAtom);
return pDescriptor;
}
void MP4DescriptorProperty::DeleteDescriptor(u_int32_t index)
{
delete m_pDescriptors[index];
m_pDescriptors.Delete(index);
}
void MP4DescriptorProperty::Generate()
{
// generate a default descriptor
// if it is mandatory, and single
if (m_mandatory && m_onlyOne) {
MP4Descriptor* pDescriptor =
AddDescriptor(m_tagsStart);
pDescriptor->Generate();
}
}
bool MP4DescriptorProperty::FindProperty(const char *name,
MP4Property** ppProperty, u_int32_t* pIndex)
{
// we're unnamed, so just check contained properties
if (m_name == NULL || !strcmp(m_name, "")) {
return FindContainedProperty(name, ppProperty, pIndex);
}
// check if first component of name matches ourselves
if (!MP4NameFirstMatches(m_name, name)) {
return false;
}
// check if the specific descriptor entry exists
u_int32_t descrIndex;
bool haveDescrIndex = MP4NameFirstIndex(name, &descrIndex);
if (haveDescrIndex && descrIndex >= GetCount()) {
return false;
}
if (m_pParentAtom) {
VERBOSE_FIND(m_pParentAtom->GetFile()->GetVerbosity(),
printf("FindProperty: matched %s\n", name));
}
// get name of descriptor property
name = MP4NameAfterFirst(name);
if (name == NULL) {
if (!haveDescrIndex) {
*ppProperty = this;
return true;
}
return false;
}
/* check rest of name */
if (haveDescrIndex) {
return m_pDescriptors[descrIndex]->FindProperty(name,
ppProperty, pIndex);
} else {
return FindContainedProperty(name, ppProperty, pIndex);
}
}
bool MP4DescriptorProperty::FindContainedProperty(const char *name,
MP4Property** ppProperty, u_int32_t* pIndex)
{
for (u_int32_t i = 0; i < m_pDescriptors.Size(); i++) {
if (m_pDescriptors[i]->FindProperty(name, ppProperty, pIndex)) {
return true;
}
}
return false;
}
void MP4DescriptorProperty::Read(MP4File* pFile, u_int32_t index)
{
ASSERT(index == 0);
if (m_implicit) {
return;
}
u_int64_t start = pFile->GetPosition();
while (true) {
// enforce size limitation
if (m_sizeLimit && pFile->GetPosition() >= start + m_sizeLimit) {
break;
}
u_int8_t tag;
try {
pFile->PeekBytes(&tag, 1);
}
catch (MP4Error* e) {
if (pFile->GetPosition() >= pFile->GetSize()) {
// EOF
delete e;
break;
}
throw e;
}
// check if tag is in desired range
if (tag < m_tagsStart || tag > m_tagsEnd) {
break;
}
MP4Descriptor* pDescriptor =
AddDescriptor(tag);
pDescriptor->Read(pFile);
}
// warnings
if (m_mandatory && m_pDescriptors.Size() == 0) {
VERBOSE_READ(pFile->GetVerbosity(),
printf("Warning: Mandatory descriptor 0x%02x missing\n",
m_tagsStart));
} else if (m_onlyOne && m_pDescriptors.Size() > 1) {
VERBOSE_READ(pFile->GetVerbosity(),
printf("Warning: Descriptor 0x%02x has more than one instance\n",
m_tagsStart));
}
}
void MP4DescriptorProperty::Write(MP4File* pFile, u_int32_t index)
{
ASSERT(index == 0);
if (m_implicit) {
return;
}
for (u_int32_t i = 0; i < m_pDescriptors.Size(); i++) {
m_pDescriptors[i]->Write(pFile);
}
}
Reference in New Issue View Git Blame Copy Permalink