initial commit for github
This commit is contained in:
Pierre
commit
60968612de
370 changed files with 68427 additions and 0 deletions
323
codec/codec.cpp
Normal file
323
codec/codec.cpp
Normal file
|
|
@ -0,0 +1,323 @@
|
|||
/**
|
||||
* @file
|
||||
* Implementation of the ADTF default media description.
|
||||
*
|
||||
* @copyright
|
||||
* @verbatim
|
||||
Copyright @ 2017 Audi Electronics Venture GmbH. All rights reserved.
|
||||
|
||||
This Source Code Form is subject to the terms of the Mozilla
|
||||
Public License, v. 2.0. If a copy of the MPL was not distributed
|
||||
with this file, You can obtain one at https://mozilla.org/MPL/2.0/.
|
||||
|
||||
If it is not possible or desirable to put the notice in a particular file, then
|
||||
You may include the notice in a location (such as a LICENSE file in a
|
||||
relevant directory) where a recipient would be likely to look for such a notice.
|
||||
|
||||
You may add additional accurate notices of copyright ownership.
|
||||
@endverbatim
|
||||
*/
|
||||
|
||||
#include "codec.h"
|
||||
|
||||
#include "a_util/result/error_def.h"
|
||||
#include "a_util/logging.h"
|
||||
#include "legacy_error_macros.h"
|
||||
#include "struct_layout.h"
|
||||
#include "static_codec.h"
|
||||
#include "element_accessor.h"
|
||||
#include "access_element.h"
|
||||
|
||||
namespace ddl
|
||||
{
|
||||
//define all needed error types and values locally
|
||||
_MAKE_RESULT(-5, ERR_INVALID_ARG)
|
||||
_MAKE_RESULT(-10, ERR_INVALID_INDEX)
|
||||
|
||||
static inline void BitToBytes(size_t& size)
|
||||
{
|
||||
if (size % 8)
|
||||
{
|
||||
size = size/ 8 + 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
size /= 8;
|
||||
}
|
||||
}
|
||||
|
||||
Decoder::Decoder(const Decoder& oDecoder, const void* pData, size_t nDataSize,
|
||||
DataRepresentation eRep):
|
||||
StaticDecoder(oDecoder._layout, pData, nDataSize, eRep),
|
||||
_dynamic_elements(oDecoder._dynamic_elements),
|
||||
_buffer_sizes(oDecoder._buffer_sizes)
|
||||
{
|
||||
}
|
||||
|
||||
Decoder::Decoder(a_util::memory::shared_ptr<const StructLayout> pLayout, const void* pData, size_t nDataSize,
|
||||
DataRepresentation eRep):
|
||||
StaticDecoder(pLayout, pData, nDataSize, eRep),
|
||||
_buffer_sizes(pLayout->getStaticBufferBitSizes())
|
||||
{
|
||||
if (_layout->hasDynamicElements())
|
||||
{
|
||||
a_util::result::Result oResult = calculateDynamicElements();
|
||||
if (isFailed(oResult))
|
||||
{
|
||||
LOG_ERROR("Failed to calculate dynamic elements");
|
||||
}
|
||||
}
|
||||
|
||||
BitToBytes(_buffer_sizes.deserialized);
|
||||
BitToBytes(_buffer_sizes.serialized);
|
||||
}
|
||||
|
||||
a_util::result::Result Decoder::isValid() const
|
||||
{
|
||||
RETURN_IF_FAILED(_layout->isValid());
|
||||
if (_data_size < getBufferSize(getRepresentation()))
|
||||
{
|
||||
return ERR_INVALID_ARG;
|
||||
}
|
||||
|
||||
return a_util::result::SUCCESS;
|
||||
}
|
||||
|
||||
a_util::result::Result Decoder::calculateDynamicElements()
|
||||
{
|
||||
_dynamic_elements.reset(new std::vector<StructLayoutElement>());
|
||||
|
||||
for (std::vector<DynamicStructLayoutElement>::const_iterator
|
||||
itDynamicElement = _layout->getDynamicElements().begin();
|
||||
itDynamicElement != _layout->getDynamicElements().end(); ++ itDynamicElement)
|
||||
{
|
||||
RETURN_IF_FAILED(addDynamicElements(*itDynamicElement, _buffer_sizes, ""));
|
||||
}
|
||||
|
||||
return a_util::result::SUCCESS;
|
||||
}
|
||||
|
||||
void Decoder::moveToAlignment(size_t& bit_offset, size_t alignment)
|
||||
{
|
||||
size_t nBitRest = bit_offset % 8;
|
||||
if (nBitRest)
|
||||
{
|
||||
bit_offset += 8 - nBitRest;
|
||||
}
|
||||
|
||||
size_t nByteOffset = bit_offset / 8;
|
||||
size_t nRest = nByteOffset % alignment;
|
||||
if (nRest)
|
||||
{
|
||||
bit_offset += (alignment - nRest) * 8;
|
||||
}
|
||||
}
|
||||
|
||||
a_util::result::Result Decoder::addDynamicElements(const DynamicStructLayoutElement& sDynamicElement,
|
||||
Offsets& sOverallOffsets,
|
||||
const std::string& strPrefix)
|
||||
{
|
||||
moveToAlignment(sOverallOffsets.deserialized, sDynamicElement.alignment);
|
||||
|
||||
if (sDynamicElement.isAlignmentElement())
|
||||
{
|
||||
return a_util::result::SUCCESS;
|
||||
}
|
||||
|
||||
a_util::variant::Variant oArraySize((uint64_t)1);
|
||||
bool bIsArray = sDynamicElement.isDynamicArray();
|
||||
if (bIsArray)
|
||||
{
|
||||
oArraySize = access_element::get_value(*this,
|
||||
strPrefix + sDynamicElement.size_element_name);
|
||||
}
|
||||
size_t nArraySize = static_cast<size_t>(oArraySize.asUInt64());
|
||||
|
||||
for (size_t nArrayIndex = 0; nArrayIndex < nArraySize; ++nArrayIndex)
|
||||
{
|
||||
RETURN_IF_FAILED(addDynamicElement(sDynamicElement,
|
||||
bIsArray ? a_util::strings::format("[%d]", nArrayIndex) : "",
|
||||
sOverallOffsets, strPrefix));
|
||||
}
|
||||
|
||||
moveToAlignment(sOverallOffsets.deserialized, sDynamicElement.alignment);
|
||||
|
||||
return a_util::result::SUCCESS;
|
||||
}
|
||||
|
||||
a_util::result::Result Decoder::addDynamicElement(const DynamicStructLayoutElement& sDynamicElement,
|
||||
const std::string& strArrayIndex,
|
||||
Offsets& sOverallOffsets,
|
||||
const std::string& strPrefix)
|
||||
{
|
||||
RETURN_IF_FAILED(addStaticStructElements(sDynamicElement, strArrayIndex, sOverallOffsets, strPrefix));
|
||||
RETURN_IF_FAILED(addDynamicStructElements(sDynamicElement, strArrayIndex, sOverallOffsets, strPrefix));
|
||||
|
||||
return a_util::result::SUCCESS;
|
||||
}
|
||||
|
||||
a_util::result::Result Decoder::addStaticStructElements(const DynamicStructLayoutElement& sDynamicElement,
|
||||
const std::string& strArrayIndex,
|
||||
Offsets& nOverallBitOffset,
|
||||
const std::string& strPrefix)
|
||||
{
|
||||
Offsets sStartOffsets = nOverallBitOffset;
|
||||
for (std::vector<StructLayoutElement>::const_iterator itStaticElement = sDynamicElement.static_elements.begin();
|
||||
itStaticElement != sDynamicElement.static_elements.end(); ++itStaticElement)
|
||||
{
|
||||
StructLayoutElement sElement = *itStaticElement;
|
||||
sElement.deserialized.bit_offset += sStartOffsets.deserialized;
|
||||
sElement.serialized.bit_offset += sStartOffsets.serialized;
|
||||
nOverallBitOffset.deserialized = sElement.deserialized.bit_offset + sElement.deserialized.bit_size;
|
||||
nOverallBitOffset.serialized = sElement.serialized.bit_offset + sElement.serialized.bit_size;
|
||||
if (!sElement.name.empty())
|
||||
{
|
||||
sElement.name = a_util::strings::format("%s%s%s.%s", strPrefix.c_str(),
|
||||
sDynamicElement.name.c_str(),
|
||||
strArrayIndex.c_str(),
|
||||
itStaticElement->name.c_str());
|
||||
}
|
||||
else
|
||||
{
|
||||
// not part of a struct, just a plain array element
|
||||
sElement.name = a_util::strings::format("%s%s%s", strPrefix.c_str(),
|
||||
sDynamicElement.name.c_str(),
|
||||
strArrayIndex.c_str());
|
||||
}
|
||||
RETURN_IF_FAILED(addDynamicStructElement(sElement));
|
||||
}
|
||||
|
||||
return a_util::result::SUCCESS;
|
||||
}
|
||||
|
||||
a_util::result::Result Decoder::addDynamicStructElements(const DynamicStructLayoutElement& sDynamicElement,
|
||||
const std::string& strArrayIndex,
|
||||
Offsets& sOverallOffsets,
|
||||
const std::string& strPrefix)
|
||||
{
|
||||
std::string strChildPrefix = a_util::strings::format("%s%s%s.", strPrefix.c_str(),
|
||||
sDynamicElement.name.c_str(),
|
||||
strArrayIndex.c_str());
|
||||
for (std::vector<DynamicStructLayoutElement>::const_iterator
|
||||
itDynamicChildElement = sDynamicElement.dynamic_elements.begin();
|
||||
itDynamicChildElement != sDynamicElement.dynamic_elements.end();
|
||||
++itDynamicChildElement)
|
||||
{
|
||||
RETURN_IF_FAILED(addDynamicElements(*itDynamicChildElement, sOverallOffsets, strChildPrefix));
|
||||
}
|
||||
|
||||
return a_util::result::SUCCESS;
|
||||
}
|
||||
|
||||
a_util::result::Result Decoder::addDynamicStructElement(const StructLayoutElement& sElement)
|
||||
{
|
||||
const Position& sPos = _element_accessor->getRepresentation() == deserialized ?
|
||||
sElement.deserialized : sElement.serialized;
|
||||
if (sPos.bit_offset + sPos.bit_size > _data_size * 8)
|
||||
{
|
||||
return ERR_INVALID_ARG;
|
||||
}
|
||||
|
||||
_dynamic_elements->push_back(sElement);
|
||||
return a_util::result::SUCCESS;
|
||||
}
|
||||
|
||||
size_t Decoder::getElementCount() const
|
||||
{
|
||||
if (_dynamic_elements)
|
||||
{
|
||||
return _layout->getStaticElements().size() + _dynamic_elements->size();
|
||||
}
|
||||
|
||||
return _layout->getStaticElements().size();
|
||||
}
|
||||
|
||||
size_t Decoder::getBufferSize(DataRepresentation eRep) const
|
||||
{
|
||||
return eRep == deserialized ?
|
||||
_buffer_sizes.deserialized :
|
||||
_buffer_sizes.serialized;
|
||||
}
|
||||
|
||||
Codec Decoder::makeCodecFor(void* pData, size_t nDataSize, DataRepresentation eRep) const
|
||||
{
|
||||
return Codec(*this, pData, nDataSize, eRep);
|
||||
}
|
||||
|
||||
const StructLayoutElement* Decoder::getLayoutElement(size_t nIndex) const
|
||||
{
|
||||
const StructLayoutElement* pElement = NULL;
|
||||
size_t nStaticElementCount = _layout->getStaticElements().size();
|
||||
if (nIndex < nStaticElementCount)
|
||||
{
|
||||
pElement = &_layout->getStaticElements()[nIndex];
|
||||
}
|
||||
else if (_dynamic_elements &&
|
||||
nIndex - nStaticElementCount < _dynamic_elements->size())
|
||||
{
|
||||
pElement = &(*_dynamic_elements)[nIndex - nStaticElementCount];
|
||||
}
|
||||
|
||||
return pElement;
|
||||
}
|
||||
|
||||
Codec::Codec(a_util::memory::shared_ptr<const StructLayout> pLayout, void* pData, size_t nDataSize,
|
||||
DataRepresentation eRep):
|
||||
Decoder(pLayout, pData, nDataSize, eRep)
|
||||
{
|
||||
}
|
||||
|
||||
Codec::Codec(const Decoder& oDecoder, void* pData, size_t nDataSize, DataRepresentation eRep):
|
||||
Decoder(oDecoder, pData, nDataSize, eRep)
|
||||
{
|
||||
}
|
||||
|
||||
a_util::result::Result Codec::setElementValue(size_t nIndex, const void* pValue)
|
||||
{
|
||||
const StructLayoutElement* pElement = getLayoutElement(nIndex);
|
||||
if (!pElement)
|
||||
{
|
||||
return ERR_INVALID_INDEX;
|
||||
}
|
||||
return _element_accessor->setValue(*pElement,
|
||||
const_cast<void*>(_data),
|
||||
_data_size,
|
||||
pValue);
|
||||
}
|
||||
|
||||
a_util::result::Result Codec::setElementValue(size_t nIndex, const a_util::variant::Variant& oValue)
|
||||
{
|
||||
const StructLayoutElement* pElement = getLayoutElement(nIndex);
|
||||
if (!pElement)
|
||||
{
|
||||
return ERR_INVALID_INDEX;
|
||||
}
|
||||
return _element_accessor->setValue(*pElement, const_cast<void*>(_data),
|
||||
_data_size, oValue);
|
||||
}
|
||||
|
||||
void* Codec::getElementAddress(size_t nIndex)
|
||||
{
|
||||
return const_cast<void*>(StaticDecoder::getElementAddress(nIndex));
|
||||
}
|
||||
|
||||
a_util::result::Result Codec::setConstants()
|
||||
{
|
||||
if (_layout->hasEnums())
|
||||
{
|
||||
size_t nElementCount = getElementCount();
|
||||
for (size_t nElement = 0; nElement < nElementCount; ++nElement)
|
||||
{
|
||||
const StructLayoutElement* pElement = getLayoutElement(nElement);
|
||||
if (pElement->constant)
|
||||
{
|
||||
RETURN_IF_FAILED(_element_accessor->setValue(*pElement, const_cast<void*>(_data),
|
||||
_data_size, *pElement->constant));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return a_util::result::SUCCESS;
|
||||
}
|
||||
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue