status_t Condition::waitRelative(Mutex& mutex, nsecs_t reltime)
{
WinCondition* condState = (WinCondition*) mState;
HANDLE hMutex = (HANDLE) mutex.mState;
nsecs_t absTime = systemTime()+reltime;
return ((WinCondition*)mState)->wait(condState, hMutex, &absTime);
}
static void waitForLiberationLocked() {
if (sThread == NULL) {
return;
}
const nsecs_t timeout = 500 * 1000 * 1000;
nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
nsecs_t timeToStop = now + timeout;
while (!sThread->mQueue.isEmpty() && now < timeToStop) {
sThread->mFreedCondition.waitRelative(sMutex, timeToStop - now);
now = systemTime(SYSTEM_TIME_MONOTONIC);
}
if (!sThread->mQueue.isEmpty()) {
ALOGW("waitForLiberationLocked timed out");
}
}
int SurfaceTextureClient::queueBuffer(android_native_buffer_t* buffer) {
LOGV("SurfaceTextureClient::queueBuffer");
#ifdef GFX_TESTFRAMEWORK
char eventID[TF_EVENT_ID_SIZE_MAX];
int idx = getSlotFromBufferLocked(buffer);
snprintf(eventID, TF_EVENT_ID_SIZE_MAX, "Q-%d", idx);
TF_PRINT(TF_EVENT_START, "STClient", eventID, "BUFFER:STC queue start");
sQueueStartTime[idx] = systemTime();
#endif
Mutex::Autolock lock(mMutex);
int64_t timestamp;
if (mTimestamp == NATIVE_WINDOW_TIMESTAMP_AUTO) {
timestamp = systemTime(SYSTEM_TIME_MONOTONIC);
LOGV("SurfaceTextureClient::queueBuffer making up timestamp: %.2f ms",
timestamp / 1000000.f);
} else {
timestamp = mTimestamp;
}
int i = getSlotFromBufferLocked(buffer);
if (i < 0) {
return i;
}
status_t err = mSurfaceTexture->queueBuffer(i, timestamp,
&mDefaultWidth, &mDefaultHeight, &mTransformHint);
if (err != OK) {
LOGE("queueBuffer: error queuing buffer to SurfaceTexture, %d", err);
}
#ifdef GFX_TESTFRAMEWORK
sQueueEndTime[i] = systemTime();
TF_PRINT(TF_EVENT_STOP, "STClient", eventID, "BUFFER:STC queue end, buffer=%p",
mSlots[i]->handle);
{
int dqTime = ns2ms(sDequeueEndTime[i] - sDequeueStartTime[i]);
int dqToLock = ns2ms(sLockStartTime[i] - sDequeueEndTime[i]);
int qTime = ns2ms(sQueueEndTime[i] - sQueueStartTime[i]);
int renderingTime = ns2ms(sQueueStartTime[i] - sLockStartTime[i]);
int totalTime = ns2ms(sQueueEndTime[i] - sDequeueStartTime[i]);
TF_PRINT(TF_EVENT, "STClient", "GFX-Timelines", "DequeueTime %d LockTime Unk QueueTime %d "
"RenderingTime %d DequeueToLockTime %d TotalTime %d bufSlot %d PID %d TID %d",
dqTime, qTime, renderingTime, dqToLock, totalTime,
i, getpid(), gettid());
}
#endif
return err;
}
void camera_take_snapshot_step(enum CAMERA_TAKEPIC_STEP step)
{
if (step > CMR_STEP_CALL_BACK) {
CMR_LOGE("error %d", step);
return;
}
cap_stp[step].timestamp = systemTime(CLOCK_MONOTONIC);
cap_stp[step].valid = 1;
}
void SystemTimePerfTimer::init()
{
DBGT_PROLOG("");
//store current time
mInitTime = systemTime(SYSTEM_TIME_REALTIME);
DBGT_EPILOG("");
}
status_t AudioPolicyManager::stopOutput(audio_io_handle_t output, AudioSystem::stream_type stream, int session)
{
LOGV("stopOutput() output %d, stream %d", output, stream);
ssize_t index = mOutputs.indexOfKey(output);
if (index < 0) {
LOGW("stopOutput() unknow output %d", output);
return BAD_VALUE;
}
AudioOutputDescriptor *outputDesc = mOutputs.valueAt(index);
routing_strategy strategy = AudioPolicyManagerBase::getStrategy((AudioSystem::stream_type)stream);
// handle special case for sonification while in call
if (isInCall()) {
AudioPolicyManagerBase::handleIncallSonification(stream, false, false);
}
if (outputDesc->mRefCount[stream] > 0) {
// decrement usage count of this stream on the output
outputDesc->changeRefCount(stream, -1);
// store time at which the last music track was stopped - see computeVolume()
if (stream == AudioSystem::MUSIC) {
outputDesc->mStopTime[stream] = systemTime();
// mMusicStopTime = systemTime();
}
#ifdef WITH_QCOM_LPA
uint32_t newDevice = AudioPolicyManagerBase::getNewDevice(mHardwareOutput, false);
if(newDevice == 0 && mLPADecodeOutput != -1) {
newDevice = AudioPolicyManagerBase::getNewDevice(mLPADecodeOutput, false);
}
setOutputDevice(output, newDevice);
#else
setOutputDevice(output, AudioPolicyManagerBase::getNewDevice(output));
#endif
#ifdef WITH_A2DP
if (mA2dpOutput != 0 && !a2dpUsedForSonification() &&
(strategy == STRATEGY_SONIFICATION || strategy == STRATEGY_ENFORCED_AUDIBLE)) {
setStrategyMute(STRATEGY_MEDIA,
false,
mA2dpOutput,
mOutputs.valueFor(mHardwareOutput)->mLatency*2);
}
#endif
if (output != mHardwareOutput) {
setOutputDevice(mHardwareOutput, AudioPolicyManagerBase::getNewDevice(mHardwareOutput), true);
}
return NO_ERROR;
} else {
LOGW("stopOutput() refcount is already 0 for output %d", output);
return INVALID_OPERATION;
}
}
void GraphicLog::logImpl(int32_t tag, int32_t buffer)
{
uint8_t scratch[2 + 2 + sizeof(int32_t) + sizeof(int64_t)];
size_t pos = 0;
scratch[pos++] = EVENT_TYPE_LIST;
scratch[pos++] = 2;
writeInt32(scratch, pos, buffer);
writeInt64(scratch, pos, ns2ms( systemTime( SYSTEM_TIME_MONOTONIC ) ));
android_bWriteLog(tag, scratch, sizeof(scratch));
}
void Layer::onLayerDisplayed() {
if (mFrameLatencyNeeded) {
const DisplayHardware& hw(graphicPlane(0).displayHardware());
mFrameStats[mFrameLatencyOffset].timestamp = mSurfaceTexture->getTimestamp();
mFrameStats[mFrameLatencyOffset].set = systemTime();
mFrameStats[mFrameLatencyOffset].vsync = hw.getRefreshTimestamp();
mFrameLatencyOffset = (mFrameLatencyOffset + 1) % 128;
mFrameLatencyNeeded = false;
}
}
/**
* override for IAtomIspObserver::atomIspNotify()
*
* signal start of 3A processing based on 3A statistics available event
* store SOF event information for future use
*/
bool AAAThread::atomIspNotify(IAtomIspObserver::Message *msg, const ObserverState state)
{
if(msg && msg->id == IAtomIspObserver::MESSAGE_ID_EVENT) {
if (mSensorEmbeddedMetaDataEnabled || msg->data.event.type == EVENT_TYPE_METADATA_READY) {
mSensorEmbeddedMetaDataEnabled = true;
// When both sensor metadata event and statistics event are ready, then triggers 3A run
if (msg->data.event.type == EVENT_TYPE_METADATA_READY) {
mTrigger3A |= EVENT_TYPE_METADATA_READY;
if (mTrigger3A & EVENT_TYPE_STATISTICS_READY) {
mTrigger3A = 0;
newStats(mCachedStatsEventMsg.data.event.timestamp, mCachedStatsEventMsg.data.event.sequence);
CLEAR(mCachedStatsEventMsg);
}
return NO_ERROR;
}
if (msg->data.event.type == EVENT_TYPE_STATISTICS_READY) {
mTrigger3A |= EVENT_TYPE_STATISTICS_READY;
if (mTrigger3A & EVENT_TYPE_METADATA_READY) {
mTrigger3A = 0;
newStats(msg->data.event.timestamp, msg->data.event.sequence);
} else {
mCachedStatsEventMsg = *msg;
}
return NO_ERROR;
}
} else if (msg->data.event.type == EVENT_TYPE_STATISTICS_READY) {
LOG2("-- STATS READY, seq %d, ts %lldus, systemTime %lldms ---",
msg->data.event.sequence,
nsecs_t(msg->data.event.timestamp.tv_sec)*1000000LL
+ nsecs_t(msg->data.event.timestamp.tv_usec),
systemTime()/1000/1000);
newStats(msg->data.event.timestamp, msg->data.event.sequence);
}
} else if (msg && msg->id == IAtomIspObserver::MESSAGE_ID_FRAME) {
LOG2("--- FRAME, seq %d, ts %lldms, systemTime %lldms ---",
msg->data.frameBuffer.buff.frameSequenceNbr,
nsecs_t(msg->data.frameBuffer.buff.capture_timestamp.tv_sec)*1000000LL
+ nsecs_t(msg->data.frameBuffer.buff.capture_timestamp.tv_usec),
systemTime()/1000/1000);
newFrame(&msg->data.frameBuffer.buff);
}
return false;
}
int Surface::queueBuffer(android_native_buffer_t* buffer, int fenceFd) {
ATRACE_CALL();
ALOGV("Surface::queueBuffer");
Mutex::Autolock lock(mMutex);
int64_t timestamp;
bool isAutoTimestamp = false;
if (mTimestamp == NATIVE_WINDOW_TIMESTAMP_AUTO) {
timestamp = systemTime(SYSTEM_TIME_MONOTONIC);
isAutoTimestamp = true;
ALOGV("Surface::queueBuffer making up timestamp: %.2f ms",
timestamp / 1000000.f);
} else {
timestamp = mTimestamp;
}
int i = getSlotFromBufferLocked(buffer);
if (i < 0) {
return i;
}
// Make sure the crop rectangle is entirely inside the buffer.
Rect crop;
mCrop.intersect(Rect(buffer->width, buffer->height), &crop);
#ifdef QCOM_BSP
Rect dirtyRect = mDirtyRect;
if(dirtyRect.isEmpty()) {
int drWidth = mUserWidth ? mUserWidth : mDefaultWidth;
int drHeight = mUserHeight ? mUserHeight : mDefaultHeight;
dirtyRect = Rect(drWidth, drHeight);
}
#endif
sp<Fence> fence(fenceFd >= 0 ? new Fence(fenceFd) : Fence::NO_FENCE);
IGraphicBufferProducer::QueueBufferOutput output;
IGraphicBufferProducer::QueueBufferInput input(timestamp, isAutoTimestamp,
crop,
#ifdef QCOM_BSP
dirtyRect,
#endif
mScalingMode, mTransform, mSwapIntervalZero,fence);
status_t err = mGraphicBufferProducer->queueBuffer(i, input, &output);
if (err != OK) {
ALOGE("queueBuffer: error queuing buffer to SurfaceTexture, %d", err);
}
uint32_t numPendingBuffers = 0;
output.deflate(&mDefaultWidth, &mDefaultHeight, &mTransformHint,
&numPendingBuffers);
mConsumerRunningBehind = (numPendingBuffers >= 2);
#ifdef QCOM_BSP
mDirtyRect.clear();
#endif
return err;
}
int FramebufferNativeWindow::dequeueBuffer(ANativeWindow* window,
android_native_buffer_t** buffer)
{
FramebufferNativeWindow* self = getSelf(window);
framebuffer_device_t* fb = self->fbDev;
int index = self->mBufferHead;
#ifdef GFX_TESTFRAMEWORK
char eventID[TF_EVENT_ID_SIZE_MAX];
snprintf(eventID, TF_EVENT_ID_SIZE_MAX, "Dequeue-%d", index);
nsecs_t start = systemTime();
TF_PRINT(TF_EVENT_START, "FBNW", eventID, "BUFFER:FBNW dequeue start");
#endif
GraphicLog& logger(GraphicLog::getInstance());
logger.log(GraphicLog::SF_FB_DEQUEUE_BEFORE, index);
/* The buffer is available, return it */
Mutex::Autolock _l(self->mutex);
// wait if the number of free buffers <= 0
while (self->mNumFreeBuffers <= 0) {
self->mCondition.wait(self->mutex);
}
self->mBufferHead++;
if (self->mBufferHead >= self->mNumBuffers)
self->mBufferHead = 0;
// get this buffer
self->mNumFreeBuffers--;
self->mCurrentBufferIndex = index;
*buffer = self->buffers[index].get();
#ifdef GFX_TESTFRAMEWORK
nsecs_t end = systemTime();
int dqtime = ns2ms(end - start);
TF_PRINT(TF_EVENT_STOP, "FBNW", eventID,
"BUFFER:FBNW dequeue end, DequeueTime %d on buf %d",
dqtime, index);
#endif
logger.log(GraphicLog::SF_FB_DEQUEUE_AFTER, index);
return 0;
}
bool SwAudioOutputCollection::isStreamActive(audio_stream_type_t stream, uint32_t inPastMs) const
{
nsecs_t sysTime = systemTime();
for (size_t i = 0; i < this->size(); i++) {
const sp<SwAudioOutputDescriptor> outputDesc = this->valueAt(i);
if (outputDesc->isStreamActive(stream, inPastMs, sysTime)) {
return true;
}
}
return false;
}
void Layer::onPostComposition() {
if (mFrameLatencyNeeded) {
const HWComposer& hwc = mFlinger->getHwComposer();
const size_t offset = mFrameLatencyOffset;
mFrameStats[offset].timestamp = mSurfaceTexture->getTimestamp();
mFrameStats[offset].set = systemTime();
mFrameStats[offset].vsync = hwc.getRefreshTimestamp(HWC_DISPLAY_PRIMARY);
mFrameLatencyOffset = (mFrameLatencyOffset + 1) % 128;
mFrameLatencyNeeded = false;
}
}
bool AudioPolicyManagerBase::isStreamActive(int stream, uint32_t inPastMs) const
{
nsecs_t sysTime = systemTime();
for (size_t i = 0; i < mOutputs.size(); i++) {
if (mOutputs.valueAt(i)->mRefCount[stream] != 0 ||
ns2ms(sysTime - mOutputs.valueAt(i)->mStopTime[stream]) < inPastMs) {
return true;
}
}
return false;
}
DisplayList::DisplayList(const DisplayListRenderer& recorder) :
mDestroyed(false), mTransformMatrix(NULL), mTransformCamera(NULL), mTransformMatrix3D(NULL),
mStaticMatrix(NULL), mAnimationMatrix(NULL) {
initFromDisplayListRenderer(recorder);
#if MTK_DEBUG_ERROR_CHECK
mTid = gettid();
mTimestamp = systemTime(SYSTEM_TIME_MONOTONIC);
Caches::getInstance().addDisplayList(this);
#endif
}
void setBrightnessValueBg_notifyRenderTime(float time)
{
static void *handle;
void *func;
int boost_level = LEVEL_BOOST_NOP, first_frame = 0;
static nsecs_t mPreviousTime = 0;
char buff[64];
nsecs_t now = systemTime(CLOCK_MONOTONIC);
//init();
setBrightnessValueBg_notifyFrameUpdate(1);
//ALOGI("setBrightnessValueBg_notifyRenderTime: time:%f", time);
#if 0
if(handle == NULL) {
handle = dlopen("libperfservice.so", RTLD_NOW);
func = dlsym(handle, "perfCalcBoostLevel");
perfCalcBoostLevel = reinterpret_cast<calc_boost_level>(func);
if (perfCalcBoostLevel == NULL) {
ALOGE("perfCalcBoostLevel init fail!");
}
}
if(mPreviousTime == 0 || (now - mPreviousTime) > RENDER_THREAD_CHECK_DURATION) { // exceed RENDER_THREAD_CHECK_DURATION => first frame
first_frame = 1;
}
mPreviousTime = now;
if(first_frame) {
//ALOGI("setBrightnessValueBg_notifyRenderTime: first_frame");
if(perfCalcBoostLevel)
perfCalcBoostLevel(0);
return;
}
if(perfCalcBoostLevel) {
boost_level = perfCalcBoostLevel(time);
}
// init value
//sprintf(buff, "notifyRenderTime:%.2f", time);
if(boost_level == LEVEL_BOOST_NOP)
return;
sprintf(buff, "levelBoost:%d", boost_level);
ATRACE_BEGIN(buff);
#if defined(MTK_LEVEL_BOOST_SUPPORT)
setBrightnessValueBg_levelBoost(boost_level);
#endif
ATRACE_END();
#endif
}
int FramebufferNativeWindow::lockBuffer(ANativeWindow* window,
android_native_buffer_t* buffer)
{
FramebufferNativeWindow* self = getSelf(window);
framebuffer_device_t* fb = self->fbDev;
int index = -1;
#ifdef GFX_TESTFRAMEWORK
char eventID[TF_EVENT_ID_SIZE_MAX];
index = self->mCurrentBufferIndex;
snprintf(eventID, TF_EVENT_ID_SIZE_MAX, "lock-%d", index);
nsecs_t start = systemTime();
TF_PRINT(TF_EVENT_START, "FBNW", eventID, "BUFFER:FBNW lock start");
#endif
{
Mutex::Autolock _l(self->mutex);
index = self->mCurrentBufferIndex;
}
GraphicLog& logger(GraphicLog::getInstance());
logger.log(GraphicLog::SF_FB_LOCK_BEFORE, index);
if (!fb->lockBuffer) {
while (self->front == buffer) {
self->mCondition.wait(self->mutex);
}
}
else {
fb->lockBuffer(fb, index);
}
logger.log(GraphicLog::SF_FB_LOCK_AFTER, index);
#ifdef GFX_TESTFRAMEWORK
nsecs_t end = systemTime();
int lktime = ns2ms(end - start);
TF_PRINT(TF_EVENT_STOP, "FBNW", eventID,
"BUFFER:FBNW lock end, LockTime %d on buf %d",
lktime, index);
#endif
return NO_ERROR;
}
int SurfaceTextureClient::dequeueBuffer(android_native_buffer_t** buffer) {
LOGV("SurfaceTextureClient::dequeueBuffer");
#ifdef GFX_TESTFRAMEWORK
nsecs_t startTime = systemTime();
TF_PRINT(TF_EVENT_START, "STClient", "DQ", "BUFFER:STC dequeue start");
#endif
Mutex::Autolock lock(mMutex);
int buf = -1;
status_t result = mSurfaceTexture->dequeueBuffer(&buf, mReqWidth, mReqHeight,
mReqFormat, mReqUsage);
if (result < 0) {
LOGV("dequeueBuffer: ISurfaceTexture::dequeueBuffer(%d, %d, %d, %d)"
"failed: %d", mReqWidth, mReqHeight, mReqFormat, mReqUsage,
result);
return result;
}
sp<GraphicBuffer>& gbuf(mSlots[buf]);
if (result & ISurfaceTexture::RELEASE_ALL_BUFFERS) {
freeAllBuffers();
}
if ((result & ISurfaceTexture::BUFFER_NEEDS_REALLOCATION) || gbuf == 0) {
result = mSurfaceTexture->requestBuffer(buf, &gbuf);
if (result != NO_ERROR) {
LOGE("dequeueBuffer: ISurfaceTexture::requestBuffer failed: %d",
result);
return result;
}
}
*buffer = gbuf.get();
#ifdef GFX_TESTFRAMEWORK
sDequeueEndTime[buf] = systemTime();
sDequeueStartTime[buf] = startTime;
TF_PRINT(TF_EVENT_STOP, "STClient", "DQ",
"BUFFER:STC dequeue end bufSlot=%d buffer=%p",
buf, mSlots[buf]->handle);
#endif
return OK;
}
void SFWatchDog::markStartTransactionTime(uint32_t index) {
Mutex::Autolock _l(mLock);
if (index >= mNodeList.size()) {
XLOGE("[unmarkStartTransactionTime] index=%d > Node list size=%d", index, mNodeList.size());
return;
}
mNodeList[index]->mStartTransactionTime = systemTime();
mUpdateCount ++;
if (mShowLog)
XLOGV("[%s] name=%s, index=%d, time = %" PRId64 "", __func__, mNodeList[index]->mName.string(), index, mNodeList[index]->mStartTransactionTime);
}
void TrimTask::run() {
acquire_wake_lock(PARTIAL_WAKE_LOCK, kWakeLock);
for (const auto& path : mPaths) {
LOG(DEBUG) << "Starting trim of " << path;
int fd = open(path.c_str(), O_RDONLY | O_DIRECTORY | O_CLOEXEC | O_NOFOLLOW);
if (fd < 0) {
PLOG(WARNING) << "Failed to open " << path;
continue;
}
struct fstrim_range range;
memset(&range, 0, sizeof(range));
range.len = ULLONG_MAX;
nsecs_t start = systemTime(SYSTEM_TIME_BOOTTIME);
if (ioctl(fd, (mFlags & Flags::kDeepTrim) ? FIDTRIM : FITRIM, &range)) {
PLOG(WARNING) << "Trim failed on " << path;
notifyResult(path, -1, -1);
} else {
nsecs_t delta = systemTime(SYSTEM_TIME_BOOTTIME) - start;
LOG(INFO) << "Trimmed " << range.len << " bytes on " << path
<< " in " << nanoseconds_to_milliseconds(delta) << "ms";
notifyResult(path, range.len, delta);
}
close(fd);
if (mFlags & Flags::kBenchmarkAfter) {
#if BENCHMARK_ENABLED
BenchmarkPrivate(path);
#else
LOG(DEBUG) << "Benchmark disabled";
#endif
}
}
release_wake_lock(kWakeLock);
}
Message* Message::createMessage(MessageHandlerInterface* target){
Message* msg = new Message();
if(NULL == msg){
return NULL;
}
msg->flags = FLAG_FREE;
msg->mTarget = target;
int i = 5;
msg->mData = reinterpret_cast<int*>(&i);
msg->when = systemTime(SYSTEM_TIME_MONOTONIC);
msg->type = TYPE_HAVE_CALLBACK;
return msg;
}
bool Caches::dumpActiveDisplayLists(DisplayList *displayList) {
Mutex::Autolock _l(mDisplayListLock);
ALOGW("Active DisplayLists: %d (%lld)", activeDisplayLists.size(), systemTime(SYSTEM_TIME_MONOTONIC));
bool isFound = false;
DisplayList *item;
for (size_t i = 0; i < activeDisplayLists.size(); i++) {
item = activeDisplayLists.itemAt(i);
ALOGW("\t[%d] %p, tid=%d, time=%lld", i, item, item->mTid, item->mTimestamp);
if (item == displayList)
isFound = true;
}
return isFound;
}
bool Caches::dumpActiveLayers(Layer *layer) {
Mutex::Autolock _l(mLayerLock);
ALOGW("Active Layers: %d (%lld)", activeLayers.size(), systemTime(SYSTEM_TIME_MONOTONIC));
bool isFound = false;
Layer *item;
for (size_t i = 0; i < activeLayers.size(); i++) {
item = activeLayers.itemAt(i);
ALOGW("\t[%d] %p, tid=%d, time=%lld", i, item, item->mTid, item->mTimestamp);
if (item == layer)
isFound = true;
}
return isFound;
}
status_t MessageQueue::queueMessage(
const sp<MessageBase>& message, nsecs_t relTime, uint32_t flags)
{
Mutex::Autolock _l(mLock);
message->when = systemTime() + relTime;
mMessages.insert(message);
//LOGD("MessageQueue::queueMessage time = %lld ms", message->when);
//dumpLocked(message);
mCondition.signal();
return NO_ERROR;
}
int SurfaceTextureClient::lockBuffer(android_native_buffer_t* buffer) {
LOGV("SurfaceTextureClient::lockBuffer");
#ifdef GFX_TESTFRAMEWORK
int i = getSlotFromBufferLocked(buffer);
char eventID[TF_EVENT_ID_SIZE_MAX];
snprintf(eventID, TF_EVENT_ID_SIZE_MAX, "Lock-%d", i);
TF_PRINT(TF_EVENT, "STClient", eventID, "BUFFER:STC lock, buffer=%p",
mSlots[i]->handle);
sLockStartTime[i] = systemTime();
#endif
Mutex::Autolock lock(mMutex);
return OK;
}
void DisplayDispatcherThread::signalEvent(int reason)
{
if(reason != 0)
{
ALOGV("signalEvent!\n");
mSemaphore->up();
mStartReason = reason;
mStartTime = systemTime()/1000;
mLastTime = mStartTime;
}
}
void VirtualDisplaySurface::onFrameCommitted() {
if (mDisplayId < 0)
return;
VDS_LOGW_IF(mDbgState != DBG_STATE_HWC,
"Unexpected onFrameCommitted() in %s state", dbgStateStr());
mDbgState = DBG_STATE_IDLE;
sp<Fence> fbFence = mHwc.getAndResetReleaseFence(mDisplayId);
if (mFbProducerSlot >= 0) {
// release the scratch buffer back to the pool
Mutex::Autolock lock(mMutex);
int sslot = mapProducer2SourceSlot(SOURCE_SCRATCH, mFbProducerSlot);
VDS_LOGV("onFrameCommitted: release scratch sslot=%d", sslot);
addReleaseFenceLocked(sslot, mProducerBuffers[mFbProducerSlot], fbFence);
releaseBufferLocked(sslot, mProducerBuffers[mFbProducerSlot],
EGL_NO_DISPLAY, EGL_NO_SYNC_KHR);
}
if (mOutputProducerSlot >= 0) {
int sslot = mapProducer2SourceSlot(SOURCE_SINK, mOutputProducerSlot);
QueueBufferOutput qbo;
sp<Fence> outFence = mHwc.getLastRetireFence(mDisplayId);
VDS_LOGV("onFrameCommitted: queue sink sslot=%d", sslot);
// Allow queuing to sink buffer if mMustRecompose is true or
// mForceHwcCopy is true. This is required to support Miracast WFD Sink
// Initiatied Pause/Resume feature support
if (mForceHwcCopy || mMustRecompose) {
status_t result = mSource[SOURCE_SINK]->queueBuffer(sslot,
QueueBufferInput(
systemTime(), false /* isAutoTimestamp */,
Rect(mSinkBufferWidth, mSinkBufferHeight),
NATIVE_WINDOW_SCALING_MODE_FREEZE, 0 /* transform */,
true /* async*/,
outFence),
&qbo);
if (result == NO_ERROR) {
updateQueueBufferOutput(qbo);
}
} else {
// If the surface hadn't actually been updated, then we only went
// through the motions of updating the display to keep our state
// machine happy. We cancel the buffer to avoid triggering another
// re-composition and causing an infinite loop.
mSource[SOURCE_SINK]->cancelBuffer(sslot, outFence);
}
}
resetPerFrameState();
}
MPerfTimer::Time SystemTimePerfTimer::elapsedTime()
{
DBGT_PROLOG("");
//get current time
nsecs_t currentTick = systemTime(SYSTEM_TIME_REALTIME);
DBGT_PTRACE("Current tick: %lld", currentTick);
Time time = (currentTick-mInitTime)/1000;
DBGT_EPILOG("");
return time;
}
bool Caches::checkInvalidDisplayLists() {
#if MTK_DEBUG_ERROR_CHECK
Mutex::Autolock _l(mDisplayListLock);
if (invalidDisplayLists.size() != 0) {
ALOGW("Invalid DisplayLists: %d (%lld)", invalidDisplayLists.size(), systemTime(SYSTEM_TIME_MONOTONIC));
for (size_t i = 0; i < invalidDisplayLists.size(); i++) {
ALOGW("\t[%d] %p", i, invalidDisplayLists.itemAt(i));
}
invalidDisplayLists.clear();
return false;
}
#endif
return true;
}
/* LGE_CHANGE_E [email protected] 2010.01.27 */ status_t AudioPolicyManagerALSA::stopOutput(audio_io_handle_t output, AudioSystem::stream_type stream) { LOGV("stopOutput() output %d, stream %d", output, stream); ssize_t index = mOutputs.indexOfKey(output); if (index < 0) { LOGW("stopOutput() unknow output %d", output); return BAD_VALUE; } AudioOutputDescriptor *outputDesc = mOutputs.valueAt(index); routing_strategy strategy = getStrategy((AudioSystem::stream_type)stream); // handle special case for sonification while in call if (mPhoneState == AudioSystem::MODE_IN_CALL) { handleIncallSonification(stream, false, false); } if (outputDesc->isUsedByStrategy(strategy)) { // decrement usage count of this stream on the output outputDesc->changeRefCount(stream, -1); if (!outputDesc->isUsedByStrategy(strategy)) { // if the stream is the last of its strategy to use this output, change routing // in the following order or priority: // PHONE > SONIFICATION > MEDIA > DTMF uint32_t newDevice = 0; if (outputDesc->isUsedByStrategy(STRATEGY_PHONE)) { newDevice = getDeviceForStrategy(STRATEGY_PHONE); } else if (outputDesc->isUsedByStrategy(STRATEGY_SONIFICATION)) { newDevice = getDeviceForStrategy(STRATEGY_SONIFICATION); } else if (mPhoneState == AudioSystem::MODE_IN_CALL) { newDevice = getDeviceForStrategy(STRATEGY_PHONE); } else if (outputDesc->isUsedByStrategy(STRATEGY_MEDIA)) { newDevice = getDeviceForStrategy(STRATEGY_MEDIA); } else if (outputDesc->isUsedByStrategy(STRATEGY_DTMF)) { newDevice = getDeviceForStrategy(STRATEGY_DTMF); } // apply routing change if necessary. // insert a delay of 2 times the audio hardware latency to ensure PCM // buffers in audio flinger and audio hardware are emptied before the // routing change is executed. setOutputDevice(mHardwareOutput, newDevice, false, mOutputs.valueFor(mHardwareOutput)->mLatency*2); } // store time at which the last music track was stopped - see computeVolume() if (stream == AudioSystem::MUSIC) { mMusicStopTime = systemTime(); } return NO_ERROR; } else { LOGW("stopOutput() refcount is already 0 for output %d", output); return INVALID_OPERATION; } }
