String8 MetaData::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;
}
void HWComposer::dump(String8& result, char* buffer, size_t SIZE,
const Vector< sp<LayerBase> >& visibleLayersSortedByZ) const {
if (mHwc && mList) {
result.append("Hardware Composer state:\n");
snprintf(buffer, SIZE, " numHwLayers=%u, flags=%08x\n",
mList->numHwLayers, mList->flags);
result.append(buffer);
result.append(
" type | handle | hints | flags | tr | blend | format | source crop | frame name \n"
"----------+----------+----------+----------+----+-------+----------+---------------------------+--------------------------------\n");
// " ________ | ________ | ________ | ________ | __ | _____ | ________ | [_____,_____,_____,_____] | [_____,_____,_____,_____]
for (size_t i=0 ; i<mList->numHwLayers ; i++) {
const hwc_layer_t& l(mList->hwLayers[i]);
const sp<LayerBase> layer(visibleLayersSortedByZ[i]);
int32_t format = -1;
if (layer->getLayer() != NULL) {
const sp<GraphicBuffer>& buffer(layer->getLayer()->getActiveBuffer());
if (buffer != NULL) {
format = buffer->getPixelFormat();
}
}
snprintf(buffer, SIZE,
" %8s | %08x | %08x | %08x | %02x | %05x | %08x | [%5d,%5d,%5d,%5d] | [%5d,%5d,%5d,%5d] %s\n",
#ifdef QCOM_HARDWARE
l.compositionType ? (l.compositionType == HWC_OVERLAY ? "OVERLAY" : "COPYBIT") : "FB",
intptr_t(l.handle), l.hints, l.flags, l.transform & FINAL_TRANSFORM_MASK, l.blending, format,
#else
l.compositionType ? "OVERLAY" : "FB",
intptr_t(l.handle), l.hints, l.flags, l.transform, l.blending, format,
#endif
l.sourceCrop.left, l.sourceCrop.top, l.sourceCrop.right, l.sourceCrop.bottom,
l.displayFrame.left, l.displayFrame.top, l.displayFrame.right, l.displayFrame.bottom,
layer->getName().string());
result.append(buffer);
}
}
if (mHwc && mHwc->common.version >= 1 && mHwc->dump) {
mHwc->dump(mHwc, buffer, SIZE);
result.append(buffer);
}
}
void SurfaceMediaSource::dump(
String8& result,
const char* /* prefix */,
char* buffer,
size_t /* SIZE */) const
{
Mutex::Autolock lock(mMutex);
result.append(buffer);
mConsumer->dump(result, "");
}
void SurfaceTexture::dump(String8& result, const char* prefix,
char* buffer, size_t SIZE) const
{
Mutex::Autolock _l(mMutex);
snprintf(buffer, SIZE, "%smTexName=%d, mAbandoned=%d\n", prefix, mTexName,
int(mAbandoned));
result.append(buffer);
snprintf(buffer, SIZE,
"%snext : {crop=[%d,%d,%d,%d], transform=0x%02x, current=%d}\n",
prefix, mCurrentCrop.left,
mCurrentCrop.top, mCurrentCrop.right, mCurrentCrop.bottom,
mCurrentTransform, mCurrentTexture
);
result.append(buffer);
if (!mAbandoned) {
mBufferQueue->dump(result, prefix, buffer, SIZE);
}
}
static void ReadFile(const char* path, String8& s) {
int fd = open(path, O_RDONLY);
if (fd != -1) {
char bytes[1024];
ssize_t byteCount;
while ((byteCount = TEMP_FAILURE_RETRY(read(fd, bytes, sizeof(bytes)))) > 0) {
s.append(bytes, byteCount);
}
close(fd);
}
}
void LayerBaseClient::dump(String8& result, char* buffer, size_t SIZE) const
{
LayerBase::dump(result, buffer, SIZE);
sp<Client> client(mClientRef.promote());
snprintf(buffer, SIZE,
" client=%p, identity=%u\n",
client.get(), getIdentity());
result.append(buffer);
}
status_t MediaPlayerService::AudioCache::dump(int fd, const Vector<String16>& args) const
{
const size_t SIZE = 256;
char buffer[SIZE];
String8 result;
result.append(" AudioCache\n");
if (mHeap != 0) {
snprintf(buffer, 255, " heap base(%p), size(%d), flags(%d), device(%s)\n",
mHeap->getBase(), mHeap->getSize(), mHeap->getFlags(), mHeap->getDevice());
result.append(buffer);
}
snprintf(buffer, 255, " msec per frame(%f), channel count(%d), format(%d), frame count(%ld)\n",
mMsecsPerFrame, mChannelCount, mFormat, mFrameCount);
result.append(buffer);
snprintf(buffer, 255, " sample rate(%d), size(%d), error(%d), command complete(%s)\n",
mSampleRate, mSize, mError, mCommandComplete?"true":"false");
result.append(buffer);
::write(fd, result.string(), result.size());
return NO_ERROR;
}
void SurfaceTexture::dumpLocked(String8& result, const char* prefix,
char* buffer, size_t size) const
{
snprintf(buffer, size,
"%smTexName=%d mCurrentTexture=%d\n"
"%smCurrentCrop=[%d,%d,%d,%d] mCurrentTransform=%#x\n",
prefix, mTexName, mCurrentTexture, prefix, mCurrentCrop.left,
mCurrentCrop.top, mCurrentCrop.right, mCurrentCrop.bottom,
mCurrentTransform);
result.append(buffer);
ConsumerBase::dumpLocked(result, prefix, buffer, size);
}
String8 getInputDeviceConfigurationFilePathByName(
const String8& name, InputDeviceConfigurationFileType type) {
// Search system repository.
String8 path;
path.setTo(getenv("ANDROID_ROOT"));
path.append("/usr/");
appendInputDeviceConfigurationFileRelativePath(path, name, type);
#if DEBUG_PROBE
ALOGD("Probing for system provided input device configuration file: path='%s'", path.string());
#endif
if (!access(path.string(), R_OK)) {
#if DEBUG_PROBE
ALOGD("Found");
#endif
return path;
}
// Search user repository.
// TODO Should only look here if not in safe mode.
path.setTo(getenv("ANDROID_DATA"));
path.append("/system/devices/");
appendInputDeviceConfigurationFileRelativePath(path, name, type);
#if DEBUG_PROBE
ALOGD("Probing for system user input device configuration file: path='%s'", path.string());
#endif
if (!access(path.string(), R_OK)) {
#if DEBUG_PROBE
ALOGD("Found");
#endif
return path;
}
// Not found.
#if DEBUG_PROBE
ALOGD("Probe failed to find input device configuration file: name='%s', type=%d",
name.string(), type);
#endif
return String8();
}
status_t AudioPolicyService::dumpPermissionDenial(int fd)
{
const size_t SIZE = 256;
char buffer[SIZE];
String8 result;
snprintf(buffer, SIZE, "Permission Denial: "
"can't dump AudioPolicyService from pid=%d, uid=%d\n",
IPCThreadState::self()->getCallingPid(),
IPCThreadState::self()->getCallingUid());
result.append(buffer);
write(fd, result.string(), result.size());
return NO_ERROR;
}
void IOProfile::dump(int fd)
{
const size_t SIZE = 256;
char buffer[SIZE];
String8 result;
AudioPort::dump(fd, 4);
snprintf(buffer, SIZE, " - flags: 0x%04x\n", getFlags());
result.append(buffer);
write(fd, result.string(), result.size());
mSupportedDevices.dump(fd, String8("Supported"), 4, false);
}
status_t ProCamera2Client::dump(int fd, const Vector<String16>& args) {
String8 result;
result.appendFormat("ProCamera2Client[%d] (%p) PID: %d, dump:\n",
mCameraId,
getRemoteCallback()->asBinder().get(),
mClientPid);
result.append(" State: ");
// TODO: print dynamic/request section from most recent requests
mFrameProcessor->dump(fd, args);
return dumpDevice(fd, args);
}
void ProgramCache::generateBlend(String8& shader, const char* name, SkXfermode::Mode mode) {
shader.append("\nvec4 ");
shader.append(name);
shader.append("(vec4 src, vec4 dst) {\n");
shader.append(" ");
shader.append(gBlendOps[mode]);
shader.append("}\n");
}
std::string SensorDevice::dump() const {
if (!mSensorModule) return "HAL not initialized\n";
String8 result;
sensor_t const* list;
int count = mSensorModule->get_sensors_list(mSensorModule, &list);
result.appendFormat("HAL: %s (%s), version %#010x\n",
mSensorModule->common.name,
mSensorModule->common.author,
getHalDeviceVersion());
result.appendFormat("Total %d h/w sensors, %zu running:\n", count, mActivationCount.size());
Mutex::Autolock _l(mLock);
for (int i = 0 ; i < count ; i++) {
const Info& info = mActivationCount.valueFor(list[i].handle);
if (info.batchParams.isEmpty()) continue;
result.appendFormat("0x%08x) active-count = %zu; ", list[i].handle,
info.batchParams.size());
result.append("sampling_period(ms) = {");
for (size_t j = 0; j < info.batchParams.size(); j++) {
const BatchParams& params = info.batchParams.valueAt(j);
result.appendFormat("%.1f%s", params.batchDelay / 1e6f,
j < info.batchParams.size() - 1 ? ", " : "");
}
result.appendFormat("}, selected = %.1f ms; ", info.bestBatchParams.batchDelay / 1e6f);
result.append("batching_period(ms) = {");
for (size_t j = 0; j < info.batchParams.size(); j++) {
BatchParams params = info.batchParams.valueAt(j);
result.appendFormat("%.1f%s", params.batchTimeout / 1e6f,
j < info.batchParams.size() - 1 ? ", " : "");
}
result.appendFormat("}, selected = %.1f ms\n", info.bestBatchParams.batchTimeout / 1e6f);
}
return result.string();
}
void SimpleBestFitAllocator::dump_l(String8& result,
const char* what) const
{
size_t size = 0;
int32_t i = 0;
chunk_t const* cur = mList.head();
const size_t SIZE = 256;
char buffer[SIZE];
snprintf(buffer, SIZE, " %s (%p, size=%u)\n",
what, this, (unsigned int)mHeapSize);
result.append(buffer);
while (cur) {
const char* errs[] = {"", "| link bogus NP",
"| link bogus PN", "| link bogus NP+PN" };
int np = ((cur->next) && cur->next->prev != cur) ? 1 : 0;
int pn = ((cur->prev) && cur->prev->next != cur) ? 2 : 0;
snprintf(buffer, SIZE, " %3u: %08x | 0x%08X | 0x%08X | %s %s\n",
i, int(cur), int(cur->start*kMemoryAlign),
int(cur->size*kMemoryAlign),
int(cur->free) ? "F" : "A",
errs[np|pn]);
result.append(buffer);
if (!cur->free)
size += cur->size*kMemoryAlign;
i++;
cur = cur->next;
}
snprintf(buffer, SIZE,
" size allocated: %u (%u KB)\n", int(size), int(size/1024));
result.append(buffer);
}
status_t CameraHardware::dump(int fd, const Vector<String16>& args) const
{
const size_t SIZE = 256;
char buffer[SIZE];
String8 result;
AutoMutex lock(&mLock);
snprintf(buffer, 255, " preview frame(%d), size (%d), running(%s)\n", mCurrentPreviewFrame, mPreviewFrameSize, mPreviewRunning?"true": "false");
result.append(buffer);
write(fd, result.string(), result.size());
return NO_ERROR;
}
void GuiExtPoolItem::dumpConsumerSlots(String8 & result, uint32_t usage, uint32_t type) const
{
uint32_t list_size = mConsumerList.size();
if (list_size > 0) {
for (uint32_t i = 0; i < list_size; i++) {
uint32_t combine_id = POOL_COMBINED_ID(usage, type, i);
sp<ConsumerSlot> consumerSlot = mConsumerList.valueFor(combine_id);
if (consumerSlot != 0) {
result.append(" ");
consumerSlot->dump(result);
} else break;
}
}
}
void FrameTracker::dump(String8& result) const {
Mutex::Autolock lock(mMutex);
processFencesLocked();
const size_t o = mOffset;
for (size_t i = 1; i < NUM_FRAME_RECORDS; i++) {
const size_t index = (o+i) % NUM_FRAME_RECORDS;
result.appendFormat("%lld\t%lld\t%lld\n",
mFrameRecords[index].desiredPresentTime,
mFrameRecords[index].actualPresentTime,
mFrameRecords[index].frameReadyTime);
}
result.append("\n");
}
void GuiExtPool::dump(String8& result) const
{
uint32_t size = mPoolList.size();
uint32_t disp_num = mDisplayList.size();
result.appendFormat("Display Num: %d\n", disp_num);
result.append("--------------------------------------------------\n");
for (uint32_t i = 0; i < disp_num; i++) {
const sp<DispInfo>& disp = mDisplayList[i];
result.appendFormat("+ DispInfo[%d]\n", i);
result.appendFormat(" type=%s, w=%d, h=%d, bufNum=%d\n",
szDisplayType[disp->type], disp->w, disp->h, disp->bufNum);
}
result.append("--------------------------------------------------\n");
result.appendFormat("\nPool List Size: %d\n", size);
result.append("--------------------------------------------------\n");
for (uint32_t i = 0; i < size; i ++) {
result.appendFormat("+ Pool[%d]\n", i);
mPoolList[i]->dump(result);
}
result.append("--------------------------------------------------\n");
}
status_t AudioAACStreamOut::dump(int fd, const Vector<String16>& args)
{
const size_t SIZE = 256;
char buffer[SIZE];
String8 result;
snprintf(buffer, SIZE, "AudioAACStreamOut::dump\n");
snprintf(buffer, SIZE, "\tsample rate: %d\n", sampleRate());
snprintf(buffer, SIZE, "\tbuffer size: %d\n", bufferSize());
snprintf(buffer, SIZE, "\tchannels: %d\n", channels());
snprintf(buffer, SIZE, "\tformat: %d\n", format());
result.append(buffer);
::write(fd, result.string(), result.size());
return NO_ERROR;
}
void Layer::dump(String8& result, char* buffer, size_t SIZE) const
{
LayerBaseClient::dump(result, buffer, SIZE);
ClientRef::Access sharedClient(mUserClientRef);
SharedBufferServer* lcblk(sharedClient.get());
uint32_t totalTime = 0;
if (lcblk) {
SharedBufferStack::Statistics stats = lcblk->getStats();
totalTime= stats.totalTime;
result.append( lcblk->dump(" ") );
}
sp<const GraphicBuffer> buf0(getBuffer(0));
sp<const GraphicBuffer> buf1(getBuffer(1));
uint32_t w0=0, h0=0, s0=0;
uint32_t w1=0, h1=0, s1=0;
if (buf0 != 0) {
w0 = buf0->getWidth();
h0 = buf0->getHeight();
s0 = buf0->getStride();
}
if (buf1 != 0) {
w1 = buf1->getWidth();
h1 = buf1->getHeight();
s1 = buf1->getStride();
}
snprintf(buffer, SIZE,
" "
"format=%2d, [%3ux%3u:%3u] [%3ux%3u:%3u],"
" freezeLock=%p, dq-q-time=%u us\n",
mFormat, w0, h0, s0, w1, h1, s1,
getFreezeLock().get(), totalTime);
result.append(buffer);
}
static void createSource(const AString &addr, int32_t port) {
sp<IServiceManager> sm = defaultServiceManager();
sp<IBinder> binder = sm->getService(String16("media.player"));
sp<IMediaPlayerService> service =
interface_cast<IMediaPlayerService>(binder);
CHECK(service.get() != NULL);
enableAudioSubmix(true /* enable */);
String8 iface;
iface.append(addr.c_str());
iface.append(StringPrintf(":%d", port).c_str());
sp<RemoteDisplayClient> client = new RemoteDisplayClient;
sp<IRemoteDisplay> display = service->listenForRemoteDisplay(client, iface);
client->waitUntilDone();
display->dispose();
display.clear();
enableAudioSubmix(false /* enable */);
}
void EventHub::dump(String8& dump) {
dump.append("Event Hub State:\n");
{ // acquire lock
AutoMutex _l(mLock);
dump.appendFormat(INDENT "BuiltInKeyboardId: %d\n", mBuiltInKeyboardId);
dump.append(INDENT "Devices:\n");
for (size_t i = 0; i < mDevices.size(); i++) {
const Device* device = mDevices.valueAt(i);
if (mBuiltInKeyboardId == device->id) {
dump.appendFormat(INDENT2 "%d: %s (aka device 0 - built-in keyboard)\n",
device->id, device->identifier.name.string());
} else {
dump.appendFormat(INDENT2 "%d: %s\n", device->id,
device->identifier.name.string());
}
dump.appendFormat(INDENT3 "Classes: 0x%08x\n", device->classes);
dump.appendFormat(INDENT3 "Path: %s\n", device->path.string());
dump.appendFormat(INDENT3 "Location: %s\n", device->identifier.location.string());
dump.appendFormat(INDENT3 "UniqueId: %s\n", device->identifier.uniqueId.string());
dump.appendFormat(INDENT3 "Identifier: bus=0x%04x, vendor=0x%04x, "
"product=0x%04x, version=0x%04x\n",
device->identifier.bus, device->identifier.vendor,
device->identifier.product, device->identifier.version);
dump.appendFormat(INDENT3 "KeyLayoutFile: %s\n",
device->keyMap.keyLayoutFile.string());
dump.appendFormat(INDENT3 "KeyCharacterMapFile: %s\n",
device->keyMap.keyCharacterMapFile.string());
dump.appendFormat(INDENT3 "ConfigurationFile: %s\n",
device->configurationFile.string());
}
} // release lock
}
String8 RsdShader::getGLSLInputString() const {
String8 s;
for (uint32_t ct=0; ct < mRSProgram->mHal.state.inputElementsCount; ct++) {
const Element *e = mRSProgram->mHal.state.inputElements[ct];
for (uint32_t field=0; field < e->mHal.state.fieldsCount; field++) {
const Element *f = e->mHal.state.fields[field];
// Cannot be complex
rsAssert(!f->mHal.state.fieldsCount);
switch (f->mHal.state.vectorSize) {
case 1: s.append("attribute float ATTRIB_"); break;
case 2: s.append("attribute vec2 ATTRIB_"); break;
case 3: s.append("attribute vec3 ATTRIB_"); break;
case 4: s.append("attribute vec4 ATTRIB_"); break;
default:
rsAssert(0);
}
s.append(e->mHal.state.fieldNames[field]);
s.append(";\n");
}
}
return s;
}
status_t Camera2ClientBase<TClientBase>::dump(int fd,
const Vector<String16>& args) {
String8 result;
result.appendFormat("Camera2ClientBase[%d] (%p) PID: %d, dump:\n",
TClientBase::mCameraId,
(TClientBase::getRemoteCallback() != NULL ?
IInterface::asBinder(TClientBase::getRemoteCallback()).get() : NULL),
TClientBase::mClientPid);
result.append(" State: ");
write(fd, result.string(), result.size());
// TODO: print dynamic/request section from most recent requests
return dumpDevice(fd, args);
}
void LayerBase::dump(String8& result, char* buffer, size_t SIZE) const
{
const Layer::State& s(drawingState());
snprintf(buffer, SIZE,
"+ %s %p\n"
" "
"z=%9d, pos=(%4d,%4d), size=(%4d,%4d), "
"needsBlending=%1d, needsDithering=%1d, invalidate=%1d, "
"alpha=0x%02x, flags=0x%08x, tr=[%.2f, %.2f][%.2f, %.2f]\n",
getTypeId(), this, s.z, tx(), ty(), s.w, s.h,
needsBlending(), needsDithering(), contentDirty,
s.alpha, s.flags,
s.transform[0][0], s.transform[0][1],
s.transform[1][0], s.transform[1][1]);
result.append(buffer);
}
sp<SurfaceControl> SurfaceComposerClient::createSurface(
DisplayID display,
uint32_t w,
uint32_t h,
PixelFormat format,
uint32_t flags)
{
String8 name;
const size_t SIZE = 128;
char buffer[SIZE];
snprintf(buffer, SIZE, "<pid_%d>", getpid());
name.append(buffer);
return SurfaceComposerClient::createSurface(name, display,
w, h, format, flags);
}
static String8 build_namespace(const Vector<namespace_entry>& namespaces,
const uint16_t* ns)
{
String8 str;
if (ns != NULL) {
str = String8(ns);
const size_t N = namespaces.size();
for (size_t i=0; i<N; i++) {
const namespace_entry& ne = namespaces.itemAt(i);
if (ne.uri == str) {
str = ne.prefix;
break;
}
}
str.append(":");
}
return str;
}
void SensorFusion::dump(String8& result, char* buffer, size_t SIZE) {
const Fusion& fusion(mFusion);
snprintf(buffer, SIZE, "9-axis fusion %s (%d clients), gyro-rate=%7.2fHz, "
"q=< %g, %g, %g, %g > (%g), "
"b=< %g, %g, %g >\n",
mEnabled ? "enabled" : "disabled",
mClients.size(),
mGyroRate,
fusion.getAttitude().x,
fusion.getAttitude().y,
fusion.getAttitude().z,
fusion.getAttitude().w,
length(fusion.getAttitude()),
fusion.getBias().x,
fusion.getBias().y,
fusion.getBias().z);
result.append(buffer);
}
void Layer::dumpStats(String8& result, char* buffer, size_t SIZE) const
{
LayerBaseClient::dumpStats(result, buffer, SIZE);
const size_t o = mFrameLatencyOffset;
const DisplayHardware& hw(graphicPlane(0).displayHardware());
const nsecs_t period = hw.getRefreshPeriod();
result.appendFormat("%lld\n", period);
for (size_t i=0 ; i<128 ; i++) {
const size_t index = (o+i) % 128;
const nsecs_t time_app = mFrameStats[index].timestamp;
const nsecs_t time_set = mFrameStats[index].set;
const nsecs_t time_vsync = mFrameStats[index].vsync;
result.appendFormat("%lld\t%lld\t%lld\n",
time_app,
time_vsync,
time_set);
}
result.append("\n");
}