/*-------------------------------------------------------------------------
|
* drawElements Quality Program Tester Core
|
* ----------------------------------------
|
*
|
* Copyright 2014 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.
|
*
|
*//*!
|
* \file
|
* \brief Access to Android internals that are not a part of the NDK.
|
*//*--------------------------------------------------------------------*/
|
|
#include "tcuAndroidInternals.hpp"
|
#include "deMemory.h"
|
#include "deStringUtil.hpp"
|
|
namespace tcu
|
{
|
namespace Android
|
{
|
namespace internal
|
{
|
|
using std::string;
|
using de::DynamicLibrary;
|
|
template<typename Func>
|
void setFuncPtr (Func*& funcPtr, DynamicLibrary& lib, const string& symname)
|
{
|
funcPtr = reinterpret_cast<Func*>(lib.getFunction(symname.c_str()));
|
if (!funcPtr)
|
TCU_THROW(NotSupportedError, ("Unable to look up symbol from shared object: " + symname).c_str());
|
}
|
|
LibUI::LibUI (void)
|
: m_library ("libui.so")
|
{
|
GraphicBufferFunctions& gb = m_functions.graphicBuffer;
|
|
setFuncPtr(gb.constructor, m_library, "_ZN7android13GraphicBufferC1Ejjij");
|
setFuncPtr(gb.destructor, m_library, "_ZN7android13GraphicBufferD1Ev");
|
setFuncPtr(gb.getNativeBuffer, m_library, "_ZNK7android13GraphicBuffer15getNativeBufferEv");
|
setFuncPtr(gb.lock, m_library, "_ZN7android13GraphicBuffer4lockEjPPv");
|
setFuncPtr(gb.unlock, m_library, "_ZN7android13GraphicBuffer6unlockEv");
|
setFuncPtr(gb.initCheck, m_library, "_ZNK7android13GraphicBuffer9initCheckEv");
|
}
|
|
#define GRAPHICBUFFER_SIZE 1024 // Hopefully enough
|
|
typedef void (*GenericFptr)();
|
|
//! call constructor with 4 arguments
|
template <typename RT, typename T1, typename T2, typename T3, typename T4>
|
RT* callConstructor4 (GenericFptr fptr, void* memory, size_t memorySize, T1 param1, T2 param2, T3 param3, T4 param4)
|
{
|
DE_UNREF(memorySize);
|
|
#if (DE_CPU == DE_CPU_ARM)
|
// C1 constructors return pointer
|
typedef RT* (*ABIFptr)(void*, T1, T2, T3, T4);
|
(void)((ABIFptr)fptr)(memory, param1, param2, param3, param4);
|
return reinterpret_cast<RT*>(memory);
|
#elif (DE_CPU == DE_CPU_ARM_64)
|
// C1 constructors return void
|
typedef void (*ABIFptr)(void*, T1, T2, T3, T4);
|
((ABIFptr)fptr)(memory, param1, param2, param3, param4);
|
return reinterpret_cast<RT*>(memory);
|
#elif (DE_CPU == DE_CPU_X86)
|
// ctor returns void
|
typedef void (*ABIFptr)(void*, T1, T2, T3, T4);
|
((ABIFptr)fptr)(memory, param1, param2, param3, param4);
|
return reinterpret_cast<RT*>(memory);
|
#elif (DE_CPU == DE_CPU_X86_64)
|
// ctor returns void
|
typedef void (*ABIFptr)(void*, T1, T2, T3, T4);
|
((ABIFptr)fptr)(memory, param1, param2, param3, param4);
|
return reinterpret_cast<RT*>(memory);
|
#else
|
DE_UNREF(fptr);
|
DE_UNREF(memory);
|
DE_UNREF(param1);
|
DE_UNREF(param2);
|
DE_UNREF(param3);
|
DE_UNREF(param4);
|
TCU_THROW(NotSupportedError, "ABI not supported");
|
return DE_NULL;
|
#endif
|
}
|
|
template <typename T>
|
void callDestructor (GenericFptr fptr, T* obj)
|
{
|
#if (DE_CPU == DE_CPU_ARM)
|
// D1 destructor returns ptr
|
typedef void* (*ABIFptr)(T* obj);
|
(void)((ABIFptr)fptr)(obj);
|
#elif (DE_CPU == DE_CPU_ARM_64)
|
// D1 destructor returns void
|
typedef void (*ABIFptr)(T* obj);
|
((ABIFptr)fptr)(obj);
|
#elif (DE_CPU == DE_CPU_X86)
|
// dtor returns void
|
typedef void (*ABIFptr)(T* obj);
|
((ABIFptr)fptr)(obj);
|
#elif (DE_CPU == DE_CPU_X86_64)
|
// dtor returns void
|
typedef void (*ABIFptr)(T* obj);
|
((ABIFptr)fptr)(obj);
|
#else
|
DE_UNREF(fptr);
|
DE_UNREF(obj);
|
TCU_THROW(NotSupportedError, "ABI not supported");
|
#endif
|
}
|
|
template<typename T1, typename T2>
|
T1* pointerToOffset (T2* ptr, size_t bytes)
|
{
|
return reinterpret_cast<T1*>((deUint8*)ptr + bytes);
|
}
|
|
static android::android_native_base_t* getAndroidNativeBase (android::GraphicBuffer* gb)
|
{
|
// \note: assuming Itanium ABI
|
return pointerToOffset<android::android_native_base_t>(gb, 2 * DE_PTR_SIZE);
|
}
|
|
//! android_native_base_t::magic for ANativeWindowBuffer
|
static deInt32 getExpectedNativeBufferVersion (void)
|
{
|
#if (DE_PTR_SIZE == 4)
|
return 96;
|
#elif (DE_PTR_SIZE == 8)
|
return 168;
|
#else
|
# error Invalid DE_PTR_SIZE
|
#endif
|
}
|
|
//! access android_native_base_t::magic
|
static deUint32 getNativeBaseMagic (android::android_native_base_t* base)
|
{
|
return *pointerToOffset<deUint32>(base, 0);
|
}
|
|
//! access android_native_base_t::version
|
static deUint32 getNativeBaseVersion (android::android_native_base_t* base)
|
{
|
return *pointerToOffset<deInt32>(base, 4);
|
}
|
|
//! access android_native_base_t::incRef
|
static NativeBaseFunctions::incRefFunc getNativeBaseIncRefFunc (android::android_native_base_t* base)
|
{
|
return *pointerToOffset<NativeBaseFunctions::incRefFunc>(base, 8 + DE_PTR_SIZE*4);
|
}
|
|
//! access android_native_base_t::decRef
|
static NativeBaseFunctions::decRefFunc getNativeBaseDecRefFunc (android::android_native_base_t* base)
|
{
|
return *pointerToOffset<NativeBaseFunctions::decRefFunc>(base, 8 + DE_PTR_SIZE*5);
|
}
|
|
static android::GraphicBuffer* createGraphicBuffer (const GraphicBufferFunctions& functions, NativeBaseFunctions& baseFunctions, deUint32 w, deUint32 h, PixelFormat format, deUint32 usage)
|
{
|
// \note: Hopefully uses the same allocator as libui
|
void* const memory = deMalloc(GRAPHICBUFFER_SIZE);
|
if (memory == DE_NULL)
|
TCU_THROW(ResourceError, "Could not alloc for GraphicBuffer");
|
else
|
{
|
try
|
{
|
android::GraphicBuffer* const gb = callConstructor4<android::GraphicBuffer, deUint32, deUint32, PixelFormat, deUint32>(functions.constructor,
|
memory,
|
GRAPHICBUFFER_SIZE,
|
w,
|
h,
|
format,
|
usage);
|
android::android_native_base_t* const base = getAndroidNativeBase(gb);
|
status_t ctorStatus = functions.initCheck(gb);
|
|
if (ctorStatus)
|
{
|
// ctor failed
|
callDestructor<android::GraphicBuffer>(functions.destructor, gb);
|
TCU_THROW(NotSupportedError, ("GraphicBuffer ctor failed, initCheck returned " + de::toString(ctorStatus)).c_str());
|
}
|
|
// check object layout
|
{
|
const deUint32 magic = getNativeBaseMagic(base);
|
const deUint32 bufferMagic = 0x5f626672u; // "_bfr"
|
|
if (magic != bufferMagic)
|
TCU_THROW(NotSupportedError, "GraphicBuffer layout unexpected");
|
}
|
|
// check object version
|
{
|
const deInt32 version = getNativeBaseVersion(base);
|
const deInt32 expectedVersion = getExpectedNativeBufferVersion();
|
|
if (version != expectedVersion)
|
TCU_THROW(NotSupportedError, "GraphicBuffer version unexpected");
|
}
|
|
// locate refcounting functions
|
|
if (!baseFunctions.incRef || !baseFunctions.decRef)
|
{
|
baseFunctions.incRef = getNativeBaseIncRefFunc(base);
|
baseFunctions.decRef = getNativeBaseDecRefFunc(base);
|
}
|
|
// take the initial reference and return
|
baseFunctions.incRef(base);
|
return gb;
|
}
|
catch (...)
|
{
|
deFree(memory);
|
throw;
|
}
|
}
|
}
|
|
GraphicBuffer::GraphicBuffer (const LibUI& lib, deUint32 width, deUint32 height, PixelFormat format, deUint32 usage)
|
: m_functions (lib.getFunctions().graphicBuffer)
|
, m_impl (DE_NULL)
|
{
|
m_baseFunctions.incRef = DE_NULL;
|
m_baseFunctions.decRef = DE_NULL;
|
|
// \note createGraphicBuffer updates m_baseFunctions
|
m_impl = createGraphicBuffer(m_functions, m_baseFunctions, width, height, format, usage);
|
}
|
|
GraphicBuffer::~GraphicBuffer (void)
|
{
|
if (m_impl && m_baseFunctions.decRef)
|
{
|
m_baseFunctions.decRef(getAndroidNativeBase(m_impl));
|
m_impl = DE_NULL;
|
}
|
}
|
|
status_t GraphicBuffer::lock (deUint32 usage, void** vaddr)
|
{
|
return m_functions.lock(m_impl, usage, vaddr);
|
}
|
|
status_t GraphicBuffer::unlock (void)
|
{
|
return m_functions.unlock(m_impl);
|
}
|
|
ANativeWindowBuffer* GraphicBuffer::getNativeBuffer (void) const
|
{
|
return m_functions.getNativeBuffer(m_impl);
|
}
|
|
} // internal
|
} // Android
|
} // tcu
|
