media/module/foundation/MetaDataBase.cpp - LeafOS-Project/android_frameworks_av - Gitiles

 /*
  * Copyright (C) 2009 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 "MetaDataBase"
 #include <inttypes.h>
 #include <utils/KeyedVector.h>
 #include <utils/Log.h>

 #include <stdlib.h>
 #include <string.h>

 #include <mutex>

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

 #if defined(__ANDROID__) && !defined(__ANDROID_VNDK__) && !defined(__ANDROID_APEX__)
 #include <binder/Parcel.h>
 #endif

 namespace android {

 struct MetaDataBase::typed_data {
     typed_data();
     ~typed_data();

     typed_data(const MetaDataBase::typed_data &);
     typed_data &operator=(const MetaDataBase::typed_data &);

     void clear();
     void setData(uint32_t type, const void *data, size_t size);
     void getData(uint32_t *type, const void **data, size_t *size) const;
     // may include hexdump of binary data if verbose=true
     String8 asString(bool verbose) const;

 private:
     uint32_t mType;
     size_t mSize;

     union {
         void *ext_data;
         float reservoir;
     } u;

     bool usesReservoir() const {
         return mSize <= sizeof(u.reservoir);
     }

     void *allocateStorage(size_t size);
     void freeStorage();

     void *storage() {
         return usesReservoir() ? &u.reservoir : u.ext_data;
     }

     const void *storage() const {
         return usesReservoir() ? &u.reservoir : u.ext_data;
     }
 };

 struct MetaDataBase::Rect {
     int32_t mLeft, mTop, mRight, mBottom;
 };


 struct MetaDataBase::MetaDataInternal {
     std::mutex mLock;
     KeyedVector<uint32_t, MetaDataBase::typed_data> mItems;
 };


 MetaDataBase::MetaDataBase()
     : mInternalData(new MetaDataInternal()) {
 }

 MetaDataBase::MetaDataBase(const MetaDataBase &from)
     : mInternalData(new MetaDataInternal()) {
     mInternalData->mItems = from.mInternalData->mItems;
 }

 MetaDataBase& MetaDataBase::operator = (const MetaDataBase &rhs) {
     this->mInternalData->mItems = rhs.mInternalData->mItems;
     return *this;
 }

 MetaDataBase::~MetaDataBase() {
     clear();
     delete mInternalData;
 }

 void MetaDataBase::clear() {
     std::lock_guard<std::mutex> guard(mInternalData->mLock);
     mInternalData->mItems.clear();
 }

 bool MetaDataBase::remove(uint32_t key) {
     std::lock_guard<std::mutex> guard(mInternalData->mLock);
     ssize_t i = mInternalData->mItems.indexOfKey(key);

     if (i < 0) {
         return false;
     }

     mInternalData->mItems.removeItemsAt(i);

     return true;
 }

 bool MetaDataBase::setCString(uint32_t key, const char *value) {
     return setData(key, TYPE_C_STRING, value, strlen(value) + 1);
 }

 bool MetaDataBase::setInt32(uint32_t key, int32_t value) {
     return setData(key, TYPE_INT32, &value, sizeof(value));
 }

 bool MetaDataBase::setInt64(uint32_t key, int64_t value) {
     return setData(key, TYPE_INT64, &value, sizeof(value));
 }

 bool MetaDataBase::setFloat(uint32_t key, float value) {
     return setData(key, TYPE_FLOAT, &value, sizeof(value));
 }

 bool MetaDataBase::setPointer(uint32_t key, void *value) {
     return setData(key, TYPE_POINTER, &value, sizeof(value));
 }

 bool MetaDataBase::setRect(
         uint32_t key,
         int32_t left, int32_t top,
         int32_t right, int32_t bottom) {
     Rect r;
     r.mLeft = left;
     r.mTop = top;
     r.mRight = right;
     r.mBottom = bottom;

     return setData(key, TYPE_RECT, &r, sizeof(r));
 }

 /**
  * Note that the returned pointer becomes invalid when additional metadata is set.
  */
 bool MetaDataBase::findCString(uint32_t key, const char **value) const {
     uint32_t type;
     const void *data;
     size_t size;
     if (!findData(key, &type, &data, &size) || type != TYPE_C_STRING) {
         return false;
     }

     *value = (const char *)data;

     return true;
 }

 bool MetaDataBase::findInt32(uint32_t key, int32_t *value) const {
     uint32_t type = 0;
     const void *data;
     size_t size;
     if (!findData(key, &type, &data, &size) || type != TYPE_INT32) {
         return false;
     }

     CHECK_EQ(size, sizeof(*value));

     *value = *(int32_t *)data;

     return true;
 }

 bool MetaDataBase::findInt64(uint32_t key, int64_t *value) const {
     uint32_t type = 0;
     const void *data;
     size_t size;
     if (!findData(key, &type, &data, &size) || type != TYPE_INT64) {
         return false;
     }

     CHECK_EQ(size, sizeof(*value));

     *value = *(int64_t *)data;

     return true;
 }

 bool MetaDataBase::findFloat(uint32_t key, float *value) const {
     uint32_t type = 0;
     const void *data;
     size_t size;
     if (!findData(key, &type, &data, &size) || type != TYPE_FLOAT) {
         return false;
     }

     CHECK_EQ(size, sizeof(*value));

     *value = *(float *)data;

     return true;
 }

 bool MetaDataBase::findPointer(uint32_t key, void **value) const {
     uint32_t type = 0;
     const void *data;
     size_t size;
     if (!findData(key, &type, &data, &size) || type != TYPE_POINTER) {
         return false;
     }

     CHECK_EQ(size, sizeof(*value));

     *value = *(void **)data;

     return true;
 }

 bool MetaDataBase::findRect(
         uint32_t key,
         int32_t *left, int32_t *top,
         int32_t *right, int32_t *bottom) const {
     uint32_t type = 0;
     const void *data;
     size_t size;
     if (!findData(key, &type, &data, &size) || type != TYPE_RECT) {
         return false;
     }

     CHECK_EQ(size, sizeof(Rect));

     const Rect *r = (const Rect *)data;
     *left = r->mLeft;
     *top = r->mTop;
     *right = r->mRight;
     *bottom = r->mBottom;

     return true;
 }

 bool MetaDataBase::setData(
         uint32_t key, uint32_t type, const void *data, size_t size) {
     bool overwrote_existing = true;

     std::lock_guard<std::mutex> guard(mInternalData->mLock);
     ssize_t i = mInternalData->mItems.indexOfKey(key);
     if (i < 0) {
         typed_data item;
         i = mInternalData->mItems.add(key, item);

         overwrote_existing = false;
     }

     typed_data &item = mInternalData->mItems.editValueAt(i);

     item.setData(type, data, size);

     return overwrote_existing;
 }

 bool MetaDataBase::findData(uint32_t key, uint32_t *type,
                         const void **data, size_t *size) const {
     std::lock_guard<std::mutex> guard(mInternalData->mLock);
     ssize_t i = mInternalData->mItems.indexOfKey(key);

     if (i < 0) {
         return false;
     }

     const typed_data &item = mInternalData->mItems.valueAt(i);

     item.getData(type, data, size);

     return true;
 }

 bool MetaDataBase::hasData(uint32_t key) const {
     std::lock_guard<std::mutex> guard(mInternalData->mLock);
     ssize_t i = mInternalData->mItems.indexOfKey(key);

     if (i < 0) {
         return false;
     }

     return true;
 }

 MetaDataBase::typed_data::typed_data()
     : mType(0),
       mSize(0) {
 }

 MetaDataBase::typed_data::~typed_data() {
     clear();
 }

 MetaDataBase::typed_data::typed_data(const typed_data &from)
     : mType(from.mType),
       mSize(0) {

     void *dst = allocateStorage(from.mSize);
     if (dst) {
         memcpy(dst, from.storage(), mSize);
     }
 }

 MetaDataBase::typed_data &MetaDataBase::typed_data::operator=(
         const MetaDataBase::typed_data &from) {
     if (this != &from) {
         clear();
         mType = from.mType;
         void *dst = allocateStorage(from.mSize);
         if (dst) {
             memcpy(dst, from.storage(), mSize);
         }
     }

     return *this;
 }

 void MetaDataBase::typed_data::clear() {
     freeStorage();

     mType = 0;
 }

 void MetaDataBase::typed_data::setData(
         uint32_t type, const void *data, size_t size) {
     clear();

     mType = type;

     void *dst = allocateStorage(size);
     if (dst) {
         memcpy(dst, data, size);
     }
 }

 void MetaDataBase::typed_data::getData(
         uint32_t *type, const void **data, size_t *size) const {
     *type = mType;
     *size = mSize;
     *data = storage();
 }

 void *MetaDataBase::typed_data::allocateStorage(size_t size) {
     mSize = size;

     if (usesReservoir()) {
         return &u.reservoir;
     }

     u.ext_data = malloc(mSize);
     if (u.ext_data == NULL) {
         ALOGE("Couldn't allocate %zu bytes for item", size);
         mSize = 0;
     }
     return u.ext_data;
 }

 void MetaDataBase::typed_data::freeStorage() {
     if (!usesReservoir()) {
         if (u.ext_data) {
             free(u.ext_data);
             u.ext_data = NULL;
         }
     }

     mSize = 0;
 }

 String8 MetaDataBase::typed_data::asString(bool verbose) const {
     String8 out;
     const void *data = storage();
     switch(mType) {
         case TYPE_NONE:
             out = String8::format("no type, size %zu)", mSize);
             break;
         case TYPE_C_STRING:
             out = String8::format("(char*) %s", (const char *)data);
             break;
         case TYPE_INT32:
             out = String8::format("(int32_t) %d", *(int32_t *)data);
             break;
         case TYPE_INT64:
             out = String8::format("(int64_t) %" PRId64, *(int64_t *)data);
             break;
         case TYPE_FLOAT:
             out = String8::format("(float) %f", *(float *)data);
             break;
         case TYPE_POINTER:
             out = String8::format("(void*) %p", *(void **)data);
             break;
         case TYPE_RECT:
         {
             const Rect *r = (const Rect *)data;
             out = String8::format("Rect(%d, %d, %d, %d)",
                                   r->mLeft, r->mTop, r->mRight, r->mBottom);
             break;
         }

         default:
             out = String8::format("(unknown type %d, size %zu)", mType, mSize);
             if (verbose && mSize <= 48) { // if it's less than three lines of hex data, dump it
                 AString foo;
                 hexdump(data, mSize, 0, &foo);
                 out.append("\n");
                 out.append(foo.c_str());
             }
             break;
     }
     return out;
 }

 static void MakeFourCCString(uint32_t x, char *s) {
     s[0] = x >> 24;
     s[1] = (x >> 16) & 0xff;
     s[2] = (x >> 8) & 0xff;
     s[3] = x & 0xff;
     s[4] = '\0';
 }

 String8 MetaDataBase::toString() const {
     String8 s;
     std::lock_guard<std::mutex> guard(mInternalData->mLock);
     for (int i = mInternalData->mItems.size(); --i >= 0;) {
         int32_t key = mInternalData->mItems.keyAt(i);
         char cc[5];
         MakeFourCCString(key, cc);
         const typed_data &item = mInternalData->mItems.valueAt(i);
         s.appendFormat("%s: %s", cc, item.asString(false).c_str());
         if (i != 0) {
             s.append(", ");
         }
     }
     return s;
 }

 void MetaDataBase::dumpToLog() const {
     std::lock_guard<std::mutex> guard(mInternalData->mLock);
     for (int i = mInternalData->mItems.size(); --i >= 0;) {
         int32_t key = mInternalData->mItems.keyAt(i);
         char cc[5];
         MakeFourCCString(key, cc);
         const typed_data &item = mInternalData->mItems.valueAt(i);
         ALOGI("%s: %s", cc, item.asString(true /* verbose */).c_str());
     }
 }

 #if defined(__ANDROID__) && !defined(__ANDROID_VNDK__) && !defined(__ANDROID_APEX__)
 status_t MetaDataBase::writeToParcel(Parcel &parcel) {
     status_t ret;
     std::lock_guard<std::mutex> guard(mInternalData->mLock);
     size_t numItems = mInternalData->mItems.size();
     ret = parcel.writeUint32(uint32_t(numItems));
     if (ret) {
         return ret;
     }
     for (size_t i = 0; i < numItems; i++) {
         int32_t key = mInternalData->mItems.keyAt(i);
         const typed_data &item = mInternalData->mItems.valueAt(i);
         uint32_t type;
         const void *data;
         size_t size;
         item.getData(&type, &data, &size);
         ret = parcel.writeInt32(key);
         if (ret) {
             return ret;
         }
         ret = parcel.writeUint32(type);
         if (ret) {
             return ret;
         }
         if (type == TYPE_NONE) {
             android::Parcel::WritableBlob blob;
             ret = parcel.writeUint32(static_cast<uint32_t>(size));
             if (ret) {
                 return ret;
             }
             ret = parcel.writeBlob(size, false, &blob);
             if (ret) {
                 return ret;
             }
             memcpy(blob.data(), data, size);
             blob.release();
         } else {
             ret = parcel.writeByteArray(size, (uint8_t*)data);
             if (ret) {
                 return ret;
             }
         }
     }
     return OK;
 }

 status_t MetaDataBase::updateFromParcel(const Parcel &parcel) {
     uint32_t numItems;
     if (parcel.readUint32(&numItems) == OK) {

         for (size_t i = 0; i < numItems; i++) {
             int32_t key;
             uint32_t type;
             uint32_t size;
             status_t ret = parcel.readInt32(&key);
             ret |= parcel.readUint32(&type);
             ret |= parcel.readUint32(&size);
             if (ret != OK) {
                 break;
             }
             // copy data from Blob, which may be inline in Parcel storage,
             // then advance position
             if (type == TYPE_NONE) {
                 android::Parcel::ReadableBlob blob;
                 ret = parcel.readBlob(size, &blob);
                 if (ret != OK) {
                     break;
                 }
                 setData(key, type, blob.data(), size);
                 blob.release();
             } else if (type == TYPE_C_STRING) {
                 // copy data directly from Parcel storage, then advance position
                 // NB: readInplace() bumps position, it is NOT idempotent.
                 const void *src = parcel.readInplace(size);
                 char *str = (char *) src;
                 if (src == nullptr || size == 0 || str[size-1] != '\0') {
                     char ccKey[5];
                     MakeFourCCString(key, ccKey);
                     if (src == nullptr) {
                         ALOGW("ignoring key '%s' string with no data (expected %d)", ccKey, size);
                     } else {
                         ALOGW("ignoring key '%s': unterminated string of %d bytes", ccKey, size);
                     }
                 } else {
                     setData(key, type, src, size);
                 }
             } else {
                 // copy data directly from Parcel storage, then advance position
                 // verify that the received size is enough
                 uint32_t needed = 0;
                 switch (type) {
                     case TYPE_INT32:
                         needed = sizeof(int32_t);
                         break;
                     case TYPE_INT64:
                         needed = sizeof(int64_t);
                         break;
                     case TYPE_FLOAT:
                         needed = sizeof(float);
                         break;
                     case TYPE_POINTER:
                         // NB: this rejects passing between 32-bit and 64-bit space.
                         needed = sizeof(void*);
                         break;
                     case TYPE_RECT:
                         needed = sizeof(Rect);
                         break;
                     default:
                         // non-standard entities can be any size >= 0
                         needed = 0;
                         break;
                 }
                 const void *src = parcel.readInplace(size);
                 if (src == nullptr || (needed != 0 && size != needed)) {
                     char ccKey[5];
                     MakeFourCCString(key, ccKey);
                     char ccType[5];
                     MakeFourCCString(type, ccType);
                     if (src == nullptr) {
                         ALOGW("ignoring key '%s' type '%s' missing data (expected %d)",
                               ccKey, ccType, size);
                     } else {
                         ALOGW("ignoring key '%s': type '%s' bytes: expected %d != %d received",
                                ccKey, ccType, needed, size);
                     }
                 } else {
                     setData(key, type, src, size);
                 }
             }
          }

         return OK;
     }
     ALOGW("no metadata in parcel");
     return UNKNOWN_ERROR;
 }
 #endif // defined(__ANDROID__) && !defined(__ANDROID_VNDK__) && !defined(__ANDROID_APEX__)

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

	#include <stdlib.h>
	#include <string.h>

	#include <mutex>

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

	#if defined(__ANDROID__) && !defined(__ANDROID_VNDK__) && !defined(__ANDROID_APEX__)
	#include <binder/Parcel.h>
	#endif

	namespace android {

	struct MetaDataBase::typed_data {
	typed_data();
	~typed_data();

	typed_data(const MetaDataBase::typed_data &);
	typed_data &operator=(const MetaDataBase::typed_data &);

	void clear();
	void setData(uint32_t type, const void *data, size_t size);
	void getData(uint32_t type, const void data, size_t size) const;
	// may include hexdump of binary data if verbose=true
	String8 asString(bool verbose) const;

	private:
	uint32_t mType;
	size_t mSize;

	union {
	void *ext_data;
	float reservoir;
	} u;

	bool usesReservoir() const {
	return mSize <= sizeof(u.reservoir);
	}

	void *allocateStorage(size_t size);
	void freeStorage();

	void *storage() {
	return usesReservoir() ? &u.reservoir : u.ext_data;
	}

	const void *storage() const {
	return usesReservoir() ? &u.reservoir : u.ext_data;
	}
	};

	struct MetaDataBase::Rect {
	int32_t mLeft, mTop, mRight, mBottom;
	};


	struct MetaDataBase::MetaDataInternal {
	std::mutex mLock;
	KeyedVector<uint32_t, MetaDataBase::typed_data> mItems;
	};


	MetaDataBase::MetaDataBase()
	: mInternalData(new MetaDataInternal()) {
	}

	MetaDataBase::MetaDataBase(const MetaDataBase &from)
	: mInternalData(new MetaDataInternal()) {
	mInternalData->mItems = from.mInternalData->mItems;
	}

	MetaDataBase& MetaDataBase::operator = (const MetaDataBase &rhs) {
	this->mInternalData->mItems = rhs.mInternalData->mItems;
	return *this;
	}

	MetaDataBase::~MetaDataBase() {
	clear();
	delete mInternalData;
	}

	void MetaDataBase::clear() {
	std::lock_guard<std::mutex> guard(mInternalData->mLock);
	mInternalData->mItems.clear();
	}

	bool MetaDataBase::remove(uint32_t key) {
	std::lock_guard<std::mutex> guard(mInternalData->mLock);
	ssize_t i = mInternalData->mItems.indexOfKey(key);

	if (i < 0) {
	return false;
	}

	mInternalData->mItems.removeItemsAt(i);

	return true;
	}

	bool MetaDataBase::setCString(uint32_t key, const char *value) {
	return setData(key, TYPE_C_STRING, value, strlen(value) + 1);
	}

	bool MetaDataBase::setInt32(uint32_t key, int32_t value) {
	return setData(key, TYPE_INT32, &value, sizeof(value));
	}

	bool MetaDataBase::setInt64(uint32_t key, int64_t value) {
	return setData(key, TYPE_INT64, &value, sizeof(value));
	}

	bool MetaDataBase::setFloat(uint32_t key, float value) {
	return setData(key, TYPE_FLOAT, &value, sizeof(value));
	}

	bool MetaDataBase::setPointer(uint32_t key, void *value) {
	return setData(key, TYPE_POINTER, &value, sizeof(value));
	}

	bool MetaDataBase::setRect(
	uint32_t key,
	int32_t left, int32_t top,
	int32_t right, int32_t bottom) {
	Rect r;
	r.mLeft = left;
	r.mTop = top;
	r.mRight = right;
	r.mBottom = bottom;

	return setData(key, TYPE_RECT, &r, sizeof(r));
	}

	/**
	* Note that the returned pointer becomes invalid when additional metadata is set.
	*/
	bool MetaDataBase::findCString(uint32_t key, const char **value) const {
	uint32_t type;
	const void *data;
	size_t size;
	if (!findData(key, &type, &data, &size) \|\| type != TYPE_C_STRING) {
	return false;
	}

	value = (const char )data;

	return true;
	}

	bool MetaDataBase::findInt32(uint32_t key, int32_t *value) const {
	uint32_t type = 0;
	const void *data;
	size_t size;
	if (!findData(key, &type, &data, &size) \|\| type != TYPE_INT32) {
	return false;
	}

	CHECK_EQ(size, sizeof(*value));

	value = (int32_t *)data;

	return true;
	}

	bool MetaDataBase::findInt64(uint32_t key, int64_t *value) const {
	uint32_t type = 0;
	const void *data;
	size_t size;
	if (!findData(key, &type, &data, &size) \|\| type != TYPE_INT64) {
	return false;
	}

	CHECK_EQ(size, sizeof(*value));

	value = (int64_t *)data;

	return true;
	}

	bool MetaDataBase::findFloat(uint32_t key, float *value) const {
	uint32_t type = 0;
	const void *data;
	size_t size;
	if (!findData(key, &type, &data, &size) \|\| type != TYPE_FLOAT) {
	return false;
	}

	CHECK_EQ(size, sizeof(*value));

	value = (float *)data;

	return true;
	}

	bool MetaDataBase::findPointer(uint32_t key, void **value) const {
	uint32_t type = 0;
	const void *data;
	size_t size;
	if (!findData(key, &type, &data, &size) \|\| type != TYPE_POINTER) {
	return false;
	}

	CHECK_EQ(size, sizeof(*value));

	value = (void **)data;

	return true;
	}

	bool MetaDataBase::findRect(
	uint32_t key,
	int32_t left, int32_t top,
	int32_t right, int32_t bottom) const {
	uint32_t type = 0;
	const void *data;
	size_t size;
	if (!findData(key, &type, &data, &size) \|\| type != TYPE_RECT) {
	return false;
	}

	CHECK_EQ(size, sizeof(Rect));

	const Rect r = (const Rect )data;
	*left = r->mLeft;
	*top = r->mTop;
	*right = r->mRight;
	*bottom = r->mBottom;

	return true;
	}

	bool MetaDataBase::setData(
	uint32_t key, uint32_t type, const void *data, size_t size) {
	bool overwrote_existing = true;

	std::lock_guard<std::mutex> guard(mInternalData->mLock);
	ssize_t i = mInternalData->mItems.indexOfKey(key);
	if (i < 0) {
	typed_data item;
	i = mInternalData->mItems.add(key, item);

	overwrote_existing = false;
	}

	typed_data &item = mInternalData->mItems.editValueAt(i);

	item.setData(type, data, size);

	return overwrote_existing;
	}

	bool MetaDataBase::findData(uint32_t key, uint32_t *type,
	const void *data, size_t size) const {
	std::lock_guard<std::mutex> guard(mInternalData->mLock);
	ssize_t i = mInternalData->mItems.indexOfKey(key);

	if (i < 0) {
	return false;
	}

	const typed_data &item = mInternalData->mItems.valueAt(i);

	item.getData(type, data, size);

	return true;
	}

	bool MetaDataBase::hasData(uint32_t key) const {
	std::lock_guard<std::mutex> guard(mInternalData->mLock);
	ssize_t i = mInternalData->mItems.indexOfKey(key);

	if (i < 0) {
	return false;
	}

	return true;
	}

	MetaDataBase::typed_data::typed_data()
	: mType(0),
	mSize(0) {
	}

	MetaDataBase::typed_data::~typed_data() {
	clear();
	}

	MetaDataBase::typed_data::typed_data(const typed_data &from)
	: mType(from.mType),
	mSize(0) {

	void *dst = allocateStorage(from.mSize);
	if (dst) {
	memcpy(dst, from.storage(), mSize);
	}
	}

	MetaDataBase::typed_data &MetaDataBase::typed_data::operator=(
	const MetaDataBase::typed_data &from) {
	if (this != &from) {
	clear();
	mType = from.mType;
	void *dst = allocateStorage(from.mSize);
	if (dst) {
	memcpy(dst, from.storage(), mSize);
	}
	}

	return *this;
	}

	void MetaDataBase::typed_data::clear() {
	freeStorage();

	mType = 0;
	}

	void MetaDataBase::typed_data::setData(
	uint32_t type, const void *data, size_t size) {
	clear();

	mType = type;

	void *dst = allocateStorage(size);
	if (dst) {
	memcpy(dst, data, size);
	}
	}

	void MetaDataBase::typed_data::getData(
	uint32_t type, const void data, size_t size) const {
	*type = mType;
	*size = mSize;
	*data = storage();
	}

	void *MetaDataBase::typed_data::allocateStorage(size_t size) {
	mSize = size;

	if (usesReservoir()) {
	return &u.reservoir;
	}

	u.ext_data = malloc(mSize);
	if (u.ext_data == NULL) {
	ALOGE("Couldn't allocate %zu bytes for item", size);
	mSize = 0;
	}
	return u.ext_data;
	}

	void MetaDataBase::typed_data::freeStorage() {
	if (!usesReservoir()) {
	if (u.ext_data) {
	free(u.ext_data);
	u.ext_data = NULL;
	}
	}

	mSize = 0;
	}

	String8 MetaDataBase::typed_data::asString(bool verbose) const {
	String8 out;
	const void *data = storage();
	switch(mType) {
	case TYPE_NONE:
	out = String8::format("no type, size %zu)", mSize);
	break;
	case TYPE_C_STRING:
	out = String8::format("(char) %s", (const char )data);
	break;
	case TYPE_INT32:
	out = String8::format("(int32_t) %d", (int32_t )data);
	break;
	case TYPE_INT64:
	out = String8::format("(int64_t) %" PRId64, (int64_t )data);
	break;
	case TYPE_FLOAT:
	out = String8::format("(float) %f", (float )data);
	break;
	case TYPE_POINTER:
	out = String8::format("(void) %p", (void **)data);
	break;
	case TYPE_RECT:
	{
	const Rect r = (const Rect )data;
	out = String8::format("Rect(%d, %d, %d, %d)",
	r->mLeft, r->mTop, r->mRight, r->mBottom);
	break;
	}

	default:
	out = String8::format("(unknown type %d, size %zu)", mType, mSize);
	if (verbose && mSize <= 48) { // if it's less than three lines of hex data, dump it
	AString foo;
	hexdump(data, mSize, 0, &foo);
	out.append("\n");
	out.append(foo.c_str());
	}
	break;
	}
	return out;
	}

	static void MakeFourCCString(uint32_t x, char *s) {
	s[0] = x >> 24;
	s[1] = (x >> 16) & 0xff;
	s[2] = (x >> 8) & 0xff;
	s[3] = x & 0xff;
	s[4] = '\0';
	}

	String8 MetaDataBase::toString() const {
	String8 s;
	std::lock_guard<std::mutex> guard(mInternalData->mLock);
	for (int i = mInternalData->mItems.size(); --i >= 0;) {
	int32_t key = mInternalData->mItems.keyAt(i);
	char cc[5];
	MakeFourCCString(key, cc);
	const typed_data &item = mInternalData->mItems.valueAt(i);
	s.appendFormat("%s: %s", cc, item.asString(false).c_str());
	if (i != 0) {
	s.append(", ");
	}
	}
	return s;
	}

	void MetaDataBase::dumpToLog() const {
	std::lock_guard<std::mutex> guard(mInternalData->mLock);
	for (int i = mInternalData->mItems.size(); --i >= 0;) {
	int32_t key = mInternalData->mItems.keyAt(i);
	char cc[5];
	MakeFourCCString(key, cc);
	const typed_data &item = mInternalData->mItems.valueAt(i);
	ALOGI("%s: %s", cc, item.asString(true /* verbose */).c_str());
	}
	}

	#if defined(__ANDROID__) && !defined(__ANDROID_VNDK__) && !defined(__ANDROID_APEX__)
	status_t MetaDataBase::writeToParcel(Parcel &parcel) {
	status_t ret;
	std::lock_guard<std::mutex> guard(mInternalData->mLock);
	size_t numItems = mInternalData->mItems.size();
	ret = parcel.writeUint32(uint32_t(numItems));
	if (ret) {
	return ret;
	}
	for (size_t i = 0; i < numItems; i++) {
	int32_t key = mInternalData->mItems.keyAt(i);
	const typed_data &item = mInternalData->mItems.valueAt(i);
	uint32_t type;
	const void *data;
	size_t size;
	item.getData(&type, &data, &size);
	ret = parcel.writeInt32(key);
	if (ret) {
	return ret;
	}
	ret = parcel.writeUint32(type);
	if (ret) {
	return ret;
	}
	if (type == TYPE_NONE) {
	android::Parcel::WritableBlob blob;
	ret = parcel.writeUint32(static_cast<uint32_t>(size));
	if (ret) {
	return ret;
	}
	ret = parcel.writeBlob(size, false, &blob);
	if (ret) {
	return ret;
	}
	memcpy(blob.data(), data, size);
	blob.release();
	} else {
	ret = parcel.writeByteArray(size, (uint8_t*)data);
	if (ret) {
	return ret;
	}
	}
	}
	return OK;
	}

	status_t MetaDataBase::updateFromParcel(const Parcel &parcel) {
	uint32_t numItems;
	if (parcel.readUint32(&numItems) == OK) {

	for (size_t i = 0; i < numItems; i++) {
	int32_t key;
	uint32_t type;
	uint32_t size;
	status_t ret = parcel.readInt32(&key);
	ret \|= parcel.readUint32(&type);
	ret \|= parcel.readUint32(&size);
	if (ret != OK) {
	break;
	}
	// copy data from Blob, which may be inline in Parcel storage,
	// then advance position
	if (type == TYPE_NONE) {
	android::Parcel::ReadableBlob blob;
	ret = parcel.readBlob(size, &blob);
	if (ret != OK) {
	break;
	}
	setData(key, type, blob.data(), size);
	blob.release();
	} else if (type == TYPE_C_STRING) {
	// copy data directly from Parcel storage, then advance position
	// NB: readInplace() bumps position, it is NOT idempotent.
	const void *src = parcel.readInplace(size);
	char str = (char ) src;
	if (src == nullptr \|\| size == 0 \|\| str[size-1] != '\0') {
	char ccKey[5];
	MakeFourCCString(key, ccKey);
	if (src == nullptr) {
	ALOGW("ignoring key '%s' string with no data (expected %d)", ccKey, size);
	} else {
	ALOGW("ignoring key '%s': unterminated string of %d bytes", ccKey, size);
	}
	} else {
	setData(key, type, src, size);
	}
	} else {
	// copy data directly from Parcel storage, then advance position
	// verify that the received size is enough
	uint32_t needed = 0;
	switch (type) {
	case TYPE_INT32:
	needed = sizeof(int32_t);
	break;
	case TYPE_INT64:
	needed = sizeof(int64_t);
	break;
	case TYPE_FLOAT:
	needed = sizeof(float);
	break;
	case TYPE_POINTER:
	// NB: this rejects passing between 32-bit and 64-bit space.
	needed = sizeof(void*);
	break;
	case TYPE_RECT:
	needed = sizeof(Rect);
	break;
	default:
	// non-standard entities can be any size >= 0
	needed = 0;
	break;
	}
	const void *src = parcel.readInplace(size);
	if (src == nullptr \|\| (needed != 0 && size != needed)) {
	char ccKey[5];
	MakeFourCCString(key, ccKey);
	char ccType[5];
	MakeFourCCString(type, ccType);
	if (src == nullptr) {
	ALOGW("ignoring key '%s' type '%s' missing data (expected %d)",
	ccKey, ccType, size);
	} else {
	ALOGW("ignoring key '%s': type '%s' bytes: expected %d != %d received",
	ccKey, ccType, needed, size);
	}
	} else {
	setData(key, type, src, size);
	}
	}
	}

	return OK;
	}
	ALOGW("no metadata in parcel");
	return UNKNOWN_ERROR;
	}
	#endif // defined(__ANDROID__) && !defined(__ANDROID_VNDK__) && !defined(__ANDROID_APEX__)

	} // namespace android