media/codec2/sfplugin/ReflectedParamUpdater.cpp - android_frameworks_av - Gitiles

 /*
  * Copyright (C) 2018 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 "ReflectedParamUpdater"
 #include <utils/Log.h>

 #include <iostream>
 #include <set>
 #include <sstream>

 #include <C2Debug.h>
 #include <C2ParamInternal.h>

 #include <media/stagefright/foundation/ABuffer.h>
 #include <media/stagefright/foundation/ADebug.h>
 #include <media/stagefright/foundation/AString.h>
 #include <media/stagefright/foundation/hexdump.h>

 #include "ReflectedParamUpdater.h"

 namespace android {

 std::string ReflectedParamUpdater::Dict::debugString(size_t indent_) const {
     std::string indent(indent_, ' ');
     std::stringstream s;
     s << "Dict {" << std::endl;

     for (const auto &it : *this) {
         s << indent << "  ";

         C2Value c2Value;
         int32_t int32Value;
         uint32_t uint32Value;
         int64_t int64Value;
         uint64_t uint64Value;
         float floatValue;
         sp<ABuffer> bufValue;
         AString strValue;
         if (it.second.find(&c2Value)) {
             switch (c2Value.type()) {
                 case C2Value::INT32:
                     (void)c2Value.get(&int32Value);
                     s << "c2::i32 " << it.first << " = " << int32Value;
                     break;
                 case C2Value::UINT32:
                     (void)c2Value.get(&uint32Value);
                     s << "c2::u32 " << it.first << " = " << uint32Value;
                     break;
                 case C2Value::CNTR32:
                     // dump counter value as unsigned
                     (void)c2Value.get((c2_cntr32_t*)&uint32Value);
                     s << "c2::c32 " << it.first << " = " << uint32Value;
                     break;
                 case C2Value::INT64:
                     (void)c2Value.get(&int64Value);
                     s << "c2::i64 " << it.first << " = " << int64Value;
                     break;
                 case C2Value::UINT64:
                     (void)c2Value.get(&uint64Value);
                     s << "c2::u64 " << it.first << " = " << uint64Value;
                     break;
                 case C2Value::CNTR64:
                     // dump counter value as unsigned
                     (void)c2Value.get((c2_cntr64_t*)&uint64Value);
                     s << "c2::c64 " << it.first << " = " << uint64Value;
                     break;
                 case C2Value::FLOAT:
                     (void)c2Value.get(&floatValue);
                     s << "c2::float " << it.first << " = " << floatValue;
                     break;
                 default:
                     // dump unsupported values for debugging, these should not be used
                     s << "c2::unsupported " << it.first;
             }
         } else if (it.second.find(&int32Value)) {
             s << "int32_t " << it.first << " = " << int32Value;
         } else if (it.second.find(&int64Value)) {
             s << "int64_t " << it.first << " = " << int64Value;
         } else if (it.second.find(&strValue)) {
             s << "string " << it.first << " = \"" << strValue.c_str() << "\"";
         } else if (it.second.find(&bufValue)) {
             s << "Buffer " << it.first << " = ";
             if (bufValue != nullptr && bufValue->data() != nullptr && bufValue->size() <= 64) {
                 s << "{" << std::endl;
                 AString tmp;
                 hexdump(bufValue->data(), bufValue->size(), indent_ + 4, &tmp);
                 s << tmp.c_str() << indent << "  }";
             } else {
                 s << (void*)bufValue.get();
             }
         } else {
             // dump unsupported values for debugging, this should never happen.
             s << "unsupported " << it.first;
         }
         s << std::endl;
     }
     s << indent << "}";

     return s.str();
 }

 void ReflectedParamUpdater::addParamDesc(
         const std::shared_ptr<C2ParamReflector> &reflector,
         const std::vector<std::shared_ptr<C2ParamDescriptor>> &paramDescs) {
     for (const std::shared_ptr<C2ParamDescriptor> &desc : paramDescs) {
         std::unique_ptr<C2StructDescriptor> structDesc = reflector->describe(
                 desc->index().coreIndex());
         if (structDesc == nullptr) {
             ALOGD("Could not describe %s", desc->name().c_str());
             continue;
         }
         addParamDesc(desc, *structDesc, reflector, true /* markVendor */);
     }
 }

 void ReflectedParamUpdater::addParamStructDesc(
         std::shared_ptr<C2ParamDescriptor> desc,
         C2String path,
         size_t offset,
         const C2StructDescriptor &structDesc,
         const std::shared_ptr<C2ParamReflector> &reflector) {
     for (auto it = structDesc.begin(); it != structDesc.end(); ++it) {
         C2String fieldName = path + "." + it->name();
         if (it->type() & C2FieldDescriptor::STRUCT_FLAG) {
             if (reflector == nullptr || it->extent() != 1) {
                 ALOGD("ignored struct field %s", fieldName.c_str());
                 continue;
             }
             std::unique_ptr<C2StructDescriptor> structDesc_ = reflector->describe(
                     C2Param::CoreIndex(it->type()).coreIndex());
             if (structDesc_ == nullptr) {
                 ALOGD("Could not describe structure of %s", fieldName.c_str());
                 continue;
             }
             addParamStructDesc(desc, fieldName, offset + _C2ParamInspector::GetOffset(*it),
                                *structDesc_, reflector);
             continue;
         }

         // verify extent and type
         switch (it->type()) {
             case C2FieldDescriptor::INT32:
             case C2FieldDescriptor::UINT32:
             case C2FieldDescriptor::CNTR32:
             case C2FieldDescriptor::INT64:
             case C2FieldDescriptor::UINT64:
             case C2FieldDescriptor::CNTR64:
             case C2FieldDescriptor::FLOAT:
                 if (it->extent() != 1) {
                     ALOGD("extent() != 1 for single value type: %s", fieldName.c_str());
                     continue;
                 }
                 break;
             case C2FieldDescriptor::STRING:
             case C2FieldDescriptor::BLOB:
                 break;

             default:
                 ALOGD("Unrecognized type: %s", fieldName.c_str());
                 continue;
         }

         ALOGV("%s registered", fieldName.c_str());
         // TODO: get the proper size by iterating through the fields.
         // only insert fields the very first time
         mMap.emplace(fieldName, FieldDesc {
             desc,
             std::make_unique<C2FieldDescriptor>(
                     it->type(), it->extent(), it->name(),
                     _C2ParamInspector::GetOffset(*it),
                     _C2ParamInspector::GetSize(*it)),
             offset,
         });
     }
 }

 void ReflectedParamUpdater::addParamDesc(
         std::shared_ptr<C2ParamDescriptor> desc, const C2StructDescriptor &structDesc,
         const std::shared_ptr<C2ParamReflector> &reflector, bool markVendor) {
     C2String paramName = desc->name();

     // Do not reflect requested parameters
     // TODO: split these once aliases are introduced into '.actual' and '.requested' and alias
     // the name to '.actual'.
     if (desc->index() & C2Param::CoreIndex::IS_REQUEST_FLAG) {
         return;
     }

     // prefix vendor parameters
     if (desc->index().isVendor() && markVendor) {
         paramName = "vendor." + paramName;
     }
     mParamNames.emplace(desc->index(), paramName);

     // also allow setting whole parameters in a binary fashion via ByteBuffer
     // this is opt-in for now
     auto it = mWholeParams.find(paramName);
     if (it != mWholeParams.end() && it->second.coreIndex() == desc->index().coreIndex()) {
         mMap.emplace(paramName, FieldDesc{ desc, nullptr, 0 /* offset */ });
         // don't add fields of whole parameters.
         return;
     }

     addParamStructDesc(desc, paramName, 0 /* offset */, structDesc, reflector);
 }

 void ReflectedParamUpdater::supportWholeParam(std::string name, C2Param::CoreIndex index) {
     mWholeParams.emplace(name, index);
 }

 std::string ReflectedParamUpdater::getParamName(C2Param::Index index) const {
     auto it = mParamNames.find(index);
     if (it != mParamNames.end()) {
         return it->second;
     }

     std::stringstream ret;
     ret << "<unknown " << index << ">";
     return ret.str();
 }

 void ReflectedParamUpdater::getParamIndicesFromMessage(
         const Dict &params,
         std::vector<C2Param::Index> *vec /* nonnull */) const {
     CHECK(vec != nullptr);
     vec->clear();
     std::set<C2Param::Index> indices;
     parseMessageAndDoWork(
             params,
             [&indices](const std::string &, const FieldDesc &desc, const void *, size_t) {
                 indices.insert(desc.paramDesc->index());
             });
     for (const C2Param::Index &index : indices) {
         vec->push_back(index);
     }
 }

 void ReflectedParamUpdater::getParamIndicesForKeys(
         const std::vector<std::string> &keys,
         std::vector<C2Param::Index> *vec /* nonnull */) const {
     CHECK(vec != nullptr);
     vec->clear();
     std::set<C2Param::Index> indices;

     std::set<std::string> keyMap(keys.begin(), keys.end());

     ALOGV("in getParamIndicesForKeys with %zu keys and map of %zu entries",
             keyMap.size(), mMap.size());
     for (const std::pair<const std::string, FieldDesc> &kv : mMap) {
         const std::string &name = kv.first;
         const FieldDesc &desc = kv.second;
         ALOGV("count of %s is %zu", name.c_str(), keyMap.count(name));
         if (keyMap.count(name) > 0) {
             indices.insert(desc.paramDesc->index());
         }
     }

     for (const C2Param::Index &index : indices) {
         vec->push_back(index);
     }
 }

 void ReflectedParamUpdater::getKeysForParamIndex(
         const C2Param::Index &index,
         std::vector<std::string> *keys /* nonnull */) const {
     CHECK(keys != nullptr);
     keys->clear();
     for (const std::pair<const std::string, FieldDesc> &kv : mMap) {
         const std::string &name = kv.first;
         const FieldDesc &desc = kv.second;
         if (desc.paramDesc->index() == index) {
             keys->push_back(name);
         }
     }
 }

 C2FieldDescriptor::type_t ReflectedParamUpdater::getTypeForKey(
         const std::string &key) const {
     auto it = mMap.find(key);
     if (it == mMap.end()) {
         return C2FieldDescriptor::type_t(~0);
     }

     if (it->second.fieldDesc) {
         return it->second.fieldDesc->type();
     }
     // whole param is exposed as a blob
     return C2FieldDescriptor::BLOB;
 }

 void ReflectedParamUpdater::updateParamsFromMessage(
         const Dict &params,
         std::vector<std::unique_ptr<C2Param>> *vec /* nonnull */) const {
     CHECK(vec != nullptr);

     std::map<C2Param::Index, std::unique_ptr<C2Param>*> paramsMap;
     for (std::unique_ptr<C2Param> &param : *vec) {
         if (param && *param) {
             paramsMap[param->index()] = &param;
         }
     }

     parseMessageAndDoWork(
             params,
             [&paramsMap](const std::string &name, const FieldDesc &desc, const void *ptr, size_t size) {
                 std::unique_ptr<C2Param> *param = nullptr;
                 auto paramIt = paramsMap.find(desc.paramDesc->index());
                 if (paramIt == paramsMap.end()) {
                     ALOGD("%s found, but param #%d isn't present to update",
                             name.c_str(), (int32_t)desc.paramDesc->index());
                     return;
                 }
                 param = paramIt->second;

                 struct _C2Param : public C2Param {
                     using C2Param::C2Param;
                     _C2Param(uint32_t size, uint32_t index) : C2Param(size, index) { }
                 };

                 // we will handle whole param updates as part of a flexible param update using
                 // a zero offset.
                 size_t offset = 0;
                 size_t minOffset = 0;

                 // if this descriptor has a field, use the offset and size and ensure that offset
                 // is not part of the header
                 if (desc.fieldDesc) {
                     minOffset = sizeof(C2Param);
                     offset = sizeof(C2Param) + desc.offset
                             + _C2ParamInspector::GetOffset(*desc.fieldDesc);
                 }

                 // reallocate or trim flexible param (or whole param) as necessary
                 if (!desc.fieldDesc /* whole param */ || desc.fieldDesc->extent() == 0) {
                     // reallocate param if more space is needed
                     if (param->get()->size() < offset + size) {
                         if (size > INT32_MAX - offset || offset < minOffset) {
                             // size too long or offset too early - abandon
                             return;
                         }
                         C2Param *newParam = (C2Param *)::operator new(offset + size);
                         new (newParam) _C2Param(offset + size, param->get()->index());
                         if (offset > sizeof(C2Param)) {
                             memcpy(newParam + 1, param->get() + 1, offset - sizeof(C2Param));
                         }
                         param->reset(newParam);
                     } else if (param->get()->size() > offset + size) {
                         // trim parameter size
                         _C2ParamInspector::TrimParam(param->get(), offset + size);
                     }
                 } else if (desc.fieldDesc->type() == C2FieldDescriptor::BLOB) {
                     // zero fill blobs if updating with smaller blob
                     if (desc.fieldDesc->extent() > size) {
                         memset((uint8_t *)(param->get()) + offset + size, 0,
                                desc.fieldDesc->extent() - size);
                     }
                 }

                 memcpy((uint8_t *)(param->get()) + offset, ptr, size);
             });
 }

 void ReflectedParamUpdater::parseMessageAndDoWork(
         const Dict &params,
         std::function<void(const std::string &, const FieldDesc &, const void *, size_t)> work) const {
     for (const std::pair<const std::string, FieldDesc> &kv : mMap) {
         const std::string &name = kv.first;
         const FieldDesc &desc = kv.second;
         auto param = params.find(name);
         if (param == params.end()) {
             continue;
         }

         // handle whole parameters
         if (!desc.fieldDesc) {
             sp<ABuffer> tmp;
             if (param->second.find(&tmp) && tmp != nullptr) {
                 C2Param *tmpAsParam = C2Param::From(tmp->data(), tmp->size());
                 if (tmpAsParam && tmpAsParam->type().type() == desc.paramDesc->index().type()) {
                     work(name, desc, tmp->data(), tmp->size());
                 } else {
                     ALOGD("Param blob does not match param for '%s' (%p, %x vs %x)",
                             name.c_str(), tmpAsParam, tmpAsParam ? tmpAsParam->type().type() : 0xDEADu,
                             desc.paramDesc->index().type());
                 }
             }
             continue;
         }

         int32_t int32Value;
         int64_t int64Value;
         C2Value c2Value;

         C2FieldDescriptor::type_t fieldType = desc.fieldDesc->type();
         size_t fieldExtent = desc.fieldDesc->extent();
         switch (fieldType) {
             case C2FieldDescriptor::INT32:
                 if ((param->second.find(&c2Value) && c2Value.get(&int32Value))
                         || param->second.find(&int32Value)) {
                     work(name, desc, &int32Value, sizeof(int32Value));
                 }
                 break;
             case C2FieldDescriptor::UINT32:
                 if ((param->second.find(&c2Value) && c2Value.get((uint32_t*)&int32Value))
                         || param->second.find(&int32Value)) {
                     work(name, desc, &int32Value, sizeof(int32Value));
                 }
                 break;
             case C2FieldDescriptor::CNTR32:
                 if ((param->second.find(&c2Value) && c2Value.get((c2_cntr32_t*)&int32Value))
                         || param->second.find(&int32Value)) {
                     work(name, desc, &int32Value, sizeof(int32Value));
                 }
                 break;
             case C2FieldDescriptor::INT64:
                 if ((param->second.find(&c2Value) && c2Value.get(&int64Value))
                         || param->second.find(&int64Value)) {
                     work(name, desc, &int64Value, sizeof(int64Value));
                 }
                 break;
             case C2FieldDescriptor::UINT64:
                 if ((param->second.find(&c2Value) && c2Value.get((uint64_t*)&int64Value))
                         || param->second.find(&int64Value)) {
                     work(name, desc, &int64Value, sizeof(int64Value));
                 }
                 break;
             case C2FieldDescriptor::CNTR64:
                 if ((param->second.find(&c2Value) && c2Value.get((c2_cntr64_t*)&int64Value))
                         || param->second.find(&int64Value)) {
                     work(name, desc, &int64Value, sizeof(int64Value));
                 }
                 break;
             case C2FieldDescriptor::FLOAT: {
                 float tmp;
                 if (param->second.find(&c2Value) && c2Value.get(&tmp)) {
                     work(name, desc, &tmp, sizeof(tmp));
                 }
                 break;
             }
             case C2FieldDescriptor::STRING: {
                 AString tmp;
                 if (!param->second.find(&tmp)) {
                     break;
                 }
                 if (fieldExtent > 0 && tmp.size() >= fieldExtent) {
                     AString truncated(tmp, 0, fieldExtent - 1);
                     ALOGD("String value too long to fit: original \"%s\" truncated to \"%s\"",
                             tmp.c_str(), truncated.c_str());
                     tmp = truncated;
                 }
                 work(name, desc, tmp.c_str(), tmp.size() + 1);
                 break;
             }

             case C2FieldDescriptor::BLOB: {
                 sp<ABuffer> tmp;
                 if (!param->second.find(&tmp) || tmp == nullptr) {
                     break;
                 }

                 if (fieldExtent > 0 && tmp->size() > fieldExtent) {
                     ALOGD("Blob value too long to fit. Truncating.");
                     tmp->setRange(tmp->offset(), fieldExtent);
                 }
                 work(name, desc, tmp->data(), tmp->size());
                 break;
             }

             default:
                 ALOGD("Unsupported data type for %s", name.c_str());
                 break;
         }
     }
 }

 ReflectedParamUpdater::Dict
 ReflectedParamUpdater::getParams(const std::vector<std::unique_ptr<C2Param>> &params_) const {
     std::vector<C2Param*> params;
     params.resize(params_.size());
     std::transform(params_.begin(), params_.end(), params.begin(),
                    [](const std::unique_ptr<C2Param>& p) -> C2Param* { return p.get(); });
     return getParams(params);
 }

 ReflectedParamUpdater::Dict
 ReflectedParamUpdater::getParams(const std::vector<C2Param*> &params) const {
     Dict ret;

     // convert vector to map
     std::map<C2Param::Index, C2Param *> paramsMap;
     for (C2Param *param : params) {
         if (param != nullptr && *param) {
             paramsMap[param->index()] = param;
         }
     }

     for (const std::pair<const std::string, FieldDesc> &kv : mMap) {
         const std::string &name = kv.first;
         const FieldDesc &desc = kv.second;
         if (paramsMap.count(desc.paramDesc->index()) == 0) {
             continue;
         }
         C2Param *param = paramsMap[desc.paramDesc->index()];
         Value value;

         // handle whole params first
         if (!desc.fieldDesc) {
             sp<ABuffer> buf = ABuffer::CreateAsCopy(param, param->size());
             value.set(buf);
             ret.emplace(name, value);
             continue;
         }

         size_t offset = sizeof(C2Param) + desc.offset
                 + _C2ParamInspector::GetOffset(*desc.fieldDesc);
         uint8_t *data = (uint8_t *)param + offset;
         C2FieldDescriptor::type_t fieldType = desc.fieldDesc->type();
         switch (fieldType) {
             case C2FieldDescriptor::STRING: {
                 size_t length = desc.fieldDesc->extent();
                 if (length == 0) {
                     length = param->size() - offset;
                 }

                 if (param->size() < length || param->size() - length < offset) {
                     ALOGD("param too small for string: length %zu size %zu offset %zu",
                             length, param->size(), offset);
                     break;
                 }
                 value.set(AString((char *)data, strnlen((char *)data, length)));
                 break;
             }

             case C2FieldDescriptor::BLOB: {
                 size_t length = desc.fieldDesc->extent();
                 if (length == 0) {
                     length = param->size() - offset;
                 }

                 if (param->size() < length || param->size() - length < offset) {
                     ALOGD("param too small for blob: length %zu size %zu offset %zu",
                             length, param->size(), offset);
                     break;
                 }

                 sp<ABuffer> buf = ABuffer::CreateAsCopy(data, length);
                 value.set(buf);
                 break;
             }

             default: {
                 size_t valueSize = C2Value::SizeFor((C2Value::type_t)fieldType);
                 if (param->size() < valueSize || param->size() - valueSize < offset) {
                     ALOGD("param too small for c2value: size %zu offset %zu",
                             param->size(), offset);
                     break;
                 }

                 C2Value c2Value;
                 switch (fieldType) {
                     case C2FieldDescriptor::INT32:  c2Value = *((int32_t *)data); break;
                     case C2FieldDescriptor::UINT32: c2Value = *((uint32_t *)data); break;
                     case C2FieldDescriptor::CNTR32: c2Value = *((c2_cntr32_t *)data); break;
                     case C2FieldDescriptor::INT64:  c2Value = *((int64_t *)data); break;
                     case C2FieldDescriptor::UINT64: c2Value = *((uint64_t *)data); break;
                     case C2FieldDescriptor::CNTR64: c2Value = *((c2_cntr64_t *)data); break;
                     case C2FieldDescriptor::FLOAT:  c2Value = *((float *)data); break;
                     default:
                         ALOGD("Unsupported data type for %s", name.c_str());
                         continue;
                 }
                 value.set(c2Value);
             }
         }
         ret.emplace(name, value);
     }
     return ret;
 }

 void ReflectedParamUpdater::clear() {
     mMap.clear();
 }

 }  // namespace android
	/*
	* Copyright (C) 2018 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 "ReflectedParamUpdater"
	#include <utils/Log.h>

	#include <iostream>
	#include <set>
	#include <sstream>

	#include <C2Debug.h>
	#include <C2ParamInternal.h>

	#include <media/stagefright/foundation/ABuffer.h>
	#include <media/stagefright/foundation/ADebug.h>
	#include <media/stagefright/foundation/AString.h>
	#include <media/stagefright/foundation/hexdump.h>

	#include "ReflectedParamUpdater.h"

	namespace android {

	std::string ReflectedParamUpdater::Dict::debugString(size_t indent_) const {
	std::string indent(indent_, ' ');
	std::stringstream s;
	s << "Dict {" << std::endl;

	for (const auto &it : *this) {
	s << indent << " ";

	C2Value c2Value;
	int32_t int32Value;
	uint32_t uint32Value;
	int64_t int64Value;
	uint64_t uint64Value;
	float floatValue;
	sp<ABuffer> bufValue;
	AString strValue;
	if (it.second.find(&c2Value)) {
	switch (c2Value.type()) {
	case C2Value::INT32:
	(void)c2Value.get(&int32Value);
	s << "c2::i32 " << it.first << " = " << int32Value;
	break;
	case C2Value::UINT32:
	(void)c2Value.get(&uint32Value);
	s << "c2::u32 " << it.first << " = " << uint32Value;
	break;
	case C2Value::CNTR32:
	// dump counter value as unsigned
	(void)c2Value.get((c2_cntr32_t*)&uint32Value);
	s << "c2::c32 " << it.first << " = " << uint32Value;
	break;
	case C2Value::INT64:
	(void)c2Value.get(&int64Value);
	s << "c2::i64 " << it.first << " = " << int64Value;
	break;
	case C2Value::UINT64:
	(void)c2Value.get(&uint64Value);
	s << "c2::u64 " << it.first << " = " << uint64Value;
	break;
	case C2Value::CNTR64:
	// dump counter value as unsigned
	(void)c2Value.get((c2_cntr64_t*)&uint64Value);
	s << "c2::c64 " << it.first << " = " << uint64Value;
	break;
	case C2Value::FLOAT:
	(void)c2Value.get(&floatValue);
	s << "c2::float " << it.first << " = " << floatValue;
	break;
	default:
	// dump unsupported values for debugging, these should not be used
	s << "c2::unsupported " << it.first;
	}
	} else if (it.second.find(&int32Value)) {
	s << "int32_t " << it.first << " = " << int32Value;
	} else if (it.second.find(&int64Value)) {
	s << "int64_t " << it.first << " = " << int64Value;
	} else if (it.second.find(&strValue)) {
	s << "string " << it.first << " = \"" << strValue.c_str() << "\"";
	} else if (it.second.find(&bufValue)) {
	s << "Buffer " << it.first << " = ";
	if (bufValue != nullptr && bufValue->data() != nullptr && bufValue->size() <= 64) {
	s << "{" << std::endl;
	AString tmp;
	hexdump(bufValue->data(), bufValue->size(), indent_ + 4, &tmp);
	s << tmp.c_str() << indent << " }";
	} else {
	s << (void*)bufValue.get();
	}
	} else {
	// dump unsupported values for debugging, this should never happen.
	s << "unsupported " << it.first;
	}
	s << std::endl;
	}
	s << indent << "}";

	return s.str();
	}

	void ReflectedParamUpdater::addParamDesc(
	const std::shared_ptr<C2ParamReflector> &reflector,
	const std::vector<std::shared_ptr<C2ParamDescriptor>> &paramDescs) {
	for (const std::shared_ptr<C2ParamDescriptor> &desc : paramDescs) {
	std::unique_ptr<C2StructDescriptor> structDesc = reflector->describe(
	desc->index().coreIndex());
	if (structDesc == nullptr) {
	ALOGD("Could not describe %s", desc->name().c_str());
	continue;
	}
	addParamDesc(desc, structDesc, reflector, true / markVendor */);
	}
	}

	void ReflectedParamUpdater::addParamStructDesc(
	std::shared_ptr<C2ParamDescriptor> desc,
	C2String path,
	size_t offset,
	const C2StructDescriptor &structDesc,
	const std::shared_ptr<C2ParamReflector> &reflector) {
	for (auto it = structDesc.begin(); it != structDesc.end(); ++it) {
	C2String fieldName = path + "." + it->name();
	if (it->type() & C2FieldDescriptor::STRUCT_FLAG) {
	if (reflector == nullptr \|\| it->extent() != 1) {
	ALOGD("ignored struct field %s", fieldName.c_str());
	continue;
	}
	std::unique_ptr<C2StructDescriptor> structDesc_ = reflector->describe(
	C2Param::CoreIndex(it->type()).coreIndex());
	if (structDesc_ == nullptr) {
	ALOGD("Could not describe structure of %s", fieldName.c_str());
	continue;
	}
	addParamStructDesc(desc, fieldName, offset + _C2ParamInspector::GetOffset(*it),
	*structDesc_, reflector);
	continue;
	}

	// verify extent and type
	switch (it->type()) {
	case C2FieldDescriptor::INT32:
	case C2FieldDescriptor::UINT32:
	case C2FieldDescriptor::CNTR32:
	case C2FieldDescriptor::INT64:
	case C2FieldDescriptor::UINT64:
	case C2FieldDescriptor::CNTR64:
	case C2FieldDescriptor::FLOAT:
	if (it->extent() != 1) {
	ALOGD("extent() != 1 for single value type: %s", fieldName.c_str());
	continue;
	}
	break;
	case C2FieldDescriptor::STRING:
	case C2FieldDescriptor::BLOB:
	break;

	default:
	ALOGD("Unrecognized type: %s", fieldName.c_str());
	continue;
	}

	ALOGV("%s registered", fieldName.c_str());
	// TODO: get the proper size by iterating through the fields.
	// only insert fields the very first time
	mMap.emplace(fieldName, FieldDesc {
	desc,
	std::make_unique<C2FieldDescriptor>(
	it->type(), it->extent(), it->name(),
	_C2ParamInspector::GetOffset(*it),
	_C2ParamInspector::GetSize(*it)),
	offset,
	});
	}
	}

	void ReflectedParamUpdater::addParamDesc(
	std::shared_ptr<C2ParamDescriptor> desc, const C2StructDescriptor &structDesc,
	const std::shared_ptr<C2ParamReflector> &reflector, bool markVendor) {
	C2String paramName = desc->name();

	// Do not reflect requested parameters
	// TODO: split these once aliases are introduced into '.actual' and '.requested' and alias
	// the name to '.actual'.
	if (desc->index() & C2Param::CoreIndex::IS_REQUEST_FLAG) {
	return;
	}

	// prefix vendor parameters
	if (desc->index().isVendor() && markVendor) {
	paramName = "vendor." + paramName;
	}
	mParamNames.emplace(desc->index(), paramName);

	// also allow setting whole parameters in a binary fashion via ByteBuffer
	// this is opt-in for now
	auto it = mWholeParams.find(paramName);
	if (it != mWholeParams.end() && it->second.coreIndex() == desc->index().coreIndex()) {
	mMap.emplace(paramName, FieldDesc{ desc, nullptr, 0 /* offset */ });
	// don't add fields of whole parameters.
	return;
	}

	addParamStructDesc(desc, paramName, 0 /* offset */, structDesc, reflector);
	}

	void ReflectedParamUpdater::supportWholeParam(std::string name, C2Param::CoreIndex index) {
	mWholeParams.emplace(name, index);
	}

	std::string ReflectedParamUpdater::getParamName(C2Param::Index index) const {
	auto it = mParamNames.find(index);
	if (it != mParamNames.end()) {
	return it->second;
	}

	std::stringstream ret;
	ret << "<unknown " << index << ">";
	return ret.str();
	}

	void ReflectedParamUpdater::getParamIndicesFromMessage(
	const Dict &params,
	std::vector<C2Param::Index> vec / nonnull */) const {
	CHECK(vec != nullptr);
	vec->clear();
	std::set<C2Param::Index> indices;
	parseMessageAndDoWork(
	params,
	[&indices](const std::string &, const FieldDesc &desc, const void *, size_t) {
	indices.insert(desc.paramDesc->index());
	});
	for (const C2Param::Index &index : indices) {
	vec->push_back(index);
	}
	}

	void ReflectedParamUpdater::getParamIndicesForKeys(
	const std::vector<std::string> &keys,
	std::vector<C2Param::Index> vec / nonnull */) const {
	CHECK(vec != nullptr);
	vec->clear();
	std::set<C2Param::Index> indices;

	std::set<std::string> keyMap(keys.begin(), keys.end());

	ALOGV("in getParamIndicesForKeys with %zu keys and map of %zu entries",
	keyMap.size(), mMap.size());
	for (const std::pair<const std::string, FieldDesc> &kv : mMap) {
	const std::string &name = kv.first;
	const FieldDesc &desc = kv.second;
	ALOGV("count of %s is %zu", name.c_str(), keyMap.count(name));
	if (keyMap.count(name) > 0) {
	indices.insert(desc.paramDesc->index());
	}
	}

	for (const C2Param::Index &index : indices) {
	vec->push_back(index);
	}
	}

	void ReflectedParamUpdater::getKeysForParamIndex(
	const C2Param::Index &index,
	std::vector<std::string> keys / nonnull */) const {
	CHECK(keys != nullptr);
	keys->clear();
	for (const std::pair<const std::string, FieldDesc> &kv : mMap) {
	const std::string &name = kv.first;
	const FieldDesc &desc = kv.second;
	if (desc.paramDesc->index() == index) {
	keys->push_back(name);
	}
	}
	}

	C2FieldDescriptor::type_t ReflectedParamUpdater::getTypeForKey(
	const std::string &key) const {
	auto it = mMap.find(key);
	if (it == mMap.end()) {
	return C2FieldDescriptor::type_t(~0);
	}

	if (it->second.fieldDesc) {
	return it->second.fieldDesc->type();
	}
	// whole param is exposed as a blob
	return C2FieldDescriptor::BLOB;
	}

	void ReflectedParamUpdater::updateParamsFromMessage(
	const Dict &params,
	std::vector<std::unique_ptr<C2Param>> vec / nonnull */) const {
	CHECK(vec != nullptr);

	std::map<C2Param::Index, std::unique_ptr<C2Param>*> paramsMap;
	for (std::unique_ptr<C2Param> &param : *vec) {
	if (param && *param) {
	paramsMap[param->index()] = &param;
	}
	}

	parseMessageAndDoWork(
	params,
	[&paramsMap](const std::string &name, const FieldDesc &desc, const void *ptr, size_t size) {
	std::unique_ptr<C2Param> *param = nullptr;
	auto paramIt = paramsMap.find(desc.paramDesc->index());
	if (paramIt == paramsMap.end()) {
	ALOGD("%s found, but param #%d isn't present to update",
	name.c_str(), (int32_t)desc.paramDesc->index());
	return;
	}
	param = paramIt->second;

	struct _C2Param : public C2Param {
	using C2Param::C2Param;
	_C2Param(uint32_t size, uint32_t index) : C2Param(size, index) { }
	};

	// we will handle whole param updates as part of a flexible param update using
	// a zero offset.
	size_t offset = 0;
	size_t minOffset = 0;

	// if this descriptor has a field, use the offset and size and ensure that offset
	// is not part of the header
	if (desc.fieldDesc) {
	minOffset = sizeof(C2Param);
	offset = sizeof(C2Param) + desc.offset
	+ _C2ParamInspector::GetOffset(*desc.fieldDesc);
	}

	// reallocate or trim flexible param (or whole param) as necessary
	if (!desc.fieldDesc /* whole param */ \|\| desc.fieldDesc->extent() == 0) {
	// reallocate param if more space is needed
	if (param->get()->size() < offset + size) {
	if (size > INT32_MAX - offset \|\| offset < minOffset) {
	// size too long or offset too early - abandon
	return;
	}
	C2Param newParam = (C2Param )::operator new(offset + size);
	new (newParam) _C2Param(offset + size, param->get()->index());
	if (offset > sizeof(C2Param)) {
	memcpy(newParam + 1, param->get() + 1, offset - sizeof(C2Param));
	}
	param->reset(newParam);
	} else if (param->get()->size() > offset + size) {
	// trim parameter size
	_C2ParamInspector::TrimParam(param->get(), offset + size);
	}
	} else if (desc.fieldDesc->type() == C2FieldDescriptor::BLOB) {
	// zero fill blobs if updating with smaller blob
	if (desc.fieldDesc->extent() > size) {
	memset((uint8_t *)(param->get()) + offset + size, 0,
	desc.fieldDesc->extent() - size);
	}
	}

	memcpy((uint8_t *)(param->get()) + offset, ptr, size);
	});
	}

	void ReflectedParamUpdater::parseMessageAndDoWork(
	const Dict &params,
	std::function<void(const std::string &, const FieldDesc &, const void *, size_t)> work) const {
	for (const std::pair<const std::string, FieldDesc> &kv : mMap) {
	const std::string &name = kv.first;
	const FieldDesc &desc = kv.second;
	auto param = params.find(name);
	if (param == params.end()) {
	continue;
	}

	// handle whole parameters
	if (!desc.fieldDesc) {
	sp<ABuffer> tmp;
	if (param->second.find(&tmp) && tmp != nullptr) {
	C2Param *tmpAsParam = C2Param::From(tmp->data(), tmp->size());
	if (tmpAsParam && tmpAsParam->type().type() == desc.paramDesc->index().type()) {
	work(name, desc, tmp->data(), tmp->size());
	} else {
	ALOGD("Param blob does not match param for '%s' (%p, %x vs %x)",
	name.c_str(), tmpAsParam, tmpAsParam ? tmpAsParam->type().type() : 0xDEADu,
	desc.paramDesc->index().type());
	}
	}
	continue;
	}

	int32_t int32Value;
	int64_t int64Value;
	C2Value c2Value;

	C2FieldDescriptor::type_t fieldType = desc.fieldDesc->type();
	size_t fieldExtent = desc.fieldDesc->extent();
	switch (fieldType) {
	case C2FieldDescriptor::INT32:
	if ((param->second.find(&c2Value) && c2Value.get(&int32Value))
	\|\| param->second.find(&int32Value)) {
	work(name, desc, &int32Value, sizeof(int32Value));
	}
	break;
	case C2FieldDescriptor::UINT32:
	if ((param->second.find(&c2Value) && c2Value.get((uint32_t*)&int32Value))
	\|\| param->second.find(&int32Value)) {
	work(name, desc, &int32Value, sizeof(int32Value));
	}
	break;
	case C2FieldDescriptor::CNTR32:
	if ((param->second.find(&c2Value) && c2Value.get((c2_cntr32_t*)&int32Value))
	\|\| param->second.find(&int32Value)) {
	work(name, desc, &int32Value, sizeof(int32Value));
	}
	break;
	case C2FieldDescriptor::INT64:
	if ((param->second.find(&c2Value) && c2Value.get(&int64Value))
	\|\| param->second.find(&int64Value)) {
	work(name, desc, &int64Value, sizeof(int64Value));
	}
	break;
	case C2FieldDescriptor::UINT64:
	if ((param->second.find(&c2Value) && c2Value.get((uint64_t*)&int64Value))
	\|\| param->second.find(&int64Value)) {
	work(name, desc, &int64Value, sizeof(int64Value));
	}
	break;
	case C2FieldDescriptor::CNTR64:
	if ((param->second.find(&c2Value) && c2Value.get((c2_cntr64_t*)&int64Value))
	\|\| param->second.find(&int64Value)) {
	work(name, desc, &int64Value, sizeof(int64Value));
	}
	break;
	case C2FieldDescriptor::FLOAT: {
	float tmp;
	if (param->second.find(&c2Value) && c2Value.get(&tmp)) {
	work(name, desc, &tmp, sizeof(tmp));
	}
	break;
	}
	case C2FieldDescriptor::STRING: {
	AString tmp;
	if (!param->second.find(&tmp)) {
	break;
	}
	if (fieldExtent > 0 && tmp.size() >= fieldExtent) {
	AString truncated(tmp, 0, fieldExtent - 1);
	ALOGD("String value too long to fit: original \"%s\" truncated to \"%s\"",
	tmp.c_str(), truncated.c_str());
	tmp = truncated;
	}
	work(name, desc, tmp.c_str(), tmp.size() + 1);
	break;
	}

	case C2FieldDescriptor::BLOB: {
	sp<ABuffer> tmp;
	if (!param->second.find(&tmp) \|\| tmp == nullptr) {
	break;
	}

	if (fieldExtent > 0 && tmp->size() > fieldExtent) {
	ALOGD("Blob value too long to fit. Truncating.");
	tmp->setRange(tmp->offset(), fieldExtent);
	}
	work(name, desc, tmp->data(), tmp->size());
	break;
	}

	default:
	ALOGD("Unsupported data type for %s", name.c_str());
	break;
	}
	}
	}

	ReflectedParamUpdater::Dict
	ReflectedParamUpdater::getParams(const std::vector<std::unique_ptr<C2Param>> &params_) const {
	std::vector<C2Param*> params;
	params.resize(params_.size());
	std::transform(params_.begin(), params_.end(), params.begin(),
	[](const std::unique_ptr<C2Param>& p) -> C2Param* { return p.get(); });
	return getParams(params);
	}

	ReflectedParamUpdater::Dict
	ReflectedParamUpdater::getParams(const std::vector<C2Param*> &params) const {
	Dict ret;

	// convert vector to map
	std::map<C2Param::Index, C2Param *> paramsMap;
	for (C2Param *param : params) {
	if (param != nullptr && *param) {
	paramsMap[param->index()] = param;
	}
	}

	for (const std::pair<const std::string, FieldDesc> &kv : mMap) {
	const std::string &name = kv.first;
	const FieldDesc &desc = kv.second;
	if (paramsMap.count(desc.paramDesc->index()) == 0) {
	continue;
	}
	C2Param *param = paramsMap[desc.paramDesc->index()];
	Value value;

	// handle whole params first
	if (!desc.fieldDesc) {
	sp<ABuffer> buf = ABuffer::CreateAsCopy(param, param->size());
	value.set(buf);
	ret.emplace(name, value);
	continue;
	}

	size_t offset = sizeof(C2Param) + desc.offset
	+ _C2ParamInspector::GetOffset(*desc.fieldDesc);
	uint8_t data = (uint8_t )param + offset;
	C2FieldDescriptor::type_t fieldType = desc.fieldDesc->type();
	switch (fieldType) {
	case C2FieldDescriptor::STRING: {
	size_t length = desc.fieldDesc->extent();
	if (length == 0) {
	length = param->size() - offset;
	}

	if (param->size() < length \|\| param->size() - length < offset) {
	ALOGD("param too small for string: length %zu size %zu offset %zu",
	length, param->size(), offset);
	break;
	}
	value.set(AString((char )data, strnlen((char )data, length)));
	break;
	}

	case C2FieldDescriptor::BLOB: {
	size_t length = desc.fieldDesc->extent();
	if (length == 0) {
	length = param->size() - offset;
	}

	if (param->size() < length \|\| param->size() - length < offset) {
	ALOGD("param too small for blob: length %zu size %zu offset %zu",
	length, param->size(), offset);
	break;
	}

	sp<ABuffer> buf = ABuffer::CreateAsCopy(data, length);
	value.set(buf);
	break;
	}

	default: {
	size_t valueSize = C2Value::SizeFor((C2Value::type_t)fieldType);
	if (param->size() < valueSize \|\| param->size() - valueSize < offset) {
	ALOGD("param too small for c2value: size %zu offset %zu",
	param->size(), offset);
	break;
	}

	C2Value c2Value;
	switch (fieldType) {
	case C2FieldDescriptor::INT32: c2Value = ((int32_t )data); break;
	case C2FieldDescriptor::UINT32: c2Value = ((uint32_t )data); break;
	case C2FieldDescriptor::CNTR32: c2Value = ((c2_cntr32_t )data); break;
	case C2FieldDescriptor::INT64: c2Value = ((int64_t )data); break;
	case C2FieldDescriptor::UINT64: c2Value = ((uint64_t )data); break;
	case C2FieldDescriptor::CNTR64: c2Value = ((c2_cntr64_t )data); break;
	case C2FieldDescriptor::FLOAT: c2Value = ((float )data); break;
	default:
	ALOGD("Unsupported data type for %s", name.c_str());
	continue;
	}
	value.set(c2Value);
	}
	}
	ret.emplace(name, value);
	}
	return ret;
	}

	void ReflectedParamUpdater::clear() {
	mMap.clear();
	}

	} // namespace android