void ModelIndexLayer::render(QPainter& painter) { if (mItemModel == NULL) { qDebug() << "Model == NULL"; // Nothing to do. return. return; } foreach(QModelIndex index, mCulled) { QGeoCoordinate coord = mItemModel->data(index, ModelIndexLayer::GeoCoordinateRole).value<QGeoCoordinate>(); if (!coord.isValid()) continue; // prepare the viewport for the delegate QRect vp = markerPosition(coord); painter.save(); painter.setClipRect(vp); painter.setWindow(QRect(0, 0, vp.width(), vp.height())); painter.setViewport(vp); MarkerInfo markerInfo; markerInfo.coord = coord; markerInfo.modelIndex = index; markerInfo.x = vp.left(); markerInfo.y = vp.top(); markerInfo.width = vp.width(); markerInfo.height = vp.height(); if (mSelectionModel != NULL) markerInfo.markerState = mSelectionModel->selection().contains(index) ? MarkerInfo::MarkerStateSelected : MarkerInfo::MarkerStateNone; QVariant v = mItemModel->data(index, ModelIndexLayer::DataRole); mDelegate->paint(painter, markerInfo, v); painter.restore(); } // else skip, this coord is not in view
nsecs_t AudioRecord::processAudioBuffer() { mLock.lock(); if (mAwaitBoost) { mAwaitBoost = false; mLock.unlock(); static const int32_t kMaxTries = 5; int32_t tryCounter = kMaxTries; uint32_t pollUs = 10000; do { int policy = sched_getscheduler(0) & ~SCHED_RESET_ON_FORK; if (policy == SCHED_FIFO || policy == SCHED_RR) { break; } usleep(pollUs); pollUs <<= 1; } while (tryCounter-- > 0); if (tryCounter < 0) { ALOGE("did not receive expected priority boost on time"); } // Run again immediately return 0; } // Can only reference mCblk while locked int32_t flags = android_atomic_and(~CBLK_OVERRUN, &mCblk->mFlags); // Check for track invalidation if (flags & CBLK_INVALID) { (void) restoreRecord_l("processAudioBuffer"); mLock.unlock(); // Run again immediately, but with a new IAudioRecord return 0; } bool active = mActive; // Manage overrun callback, must be done under lock to avoid race with releaseBuffer() bool newOverrun = false; if (flags & CBLK_OVERRUN) { if (!mInOverrun) { mInOverrun = true; newOverrun = true; } } // Get current position of server Modulo<uint32_t> position(mProxy->getPosition()); // Manage marker callback bool markerReached = false; Modulo<uint32_t> markerPosition(mMarkerPosition); // FIXME fails for wraparound, need 64 bits if (!mMarkerReached && markerPosition.value() > 0 && position >= markerPosition) { mMarkerReached = markerReached = true; } // Determine the number of new position callback(s) that will be needed, while locked size_t newPosCount = 0; Modulo<uint32_t> newPosition(mNewPosition); uint32_t updatePeriod = mUpdatePeriod; // FIXME fails for wraparound, need 64 bits if (updatePeriod > 0 && position >= newPosition) { newPosCount = ((position - newPosition).value() / updatePeriod) + 1; mNewPosition += updatePeriod * newPosCount; } // Cache other fields that will be needed soon uint32_t notificationFrames = mNotificationFramesAct; if (mRefreshRemaining) { mRefreshRemaining = false; mRemainingFrames = notificationFrames; mRetryOnPartialBuffer = false; } size_t misalignment = mProxy->getMisalignment(); uint32_t sequence = mSequence; // These fields don't need to be cached, because they are assigned only by set(): // mTransfer, mCbf, mUserData, mSampleRate, mFrameSize mLock.unlock(); // perform callbacks while unlocked if (newOverrun) { mCbf(EVENT_OVERRUN, mUserData, NULL); } if (markerReached) { mCbf(EVENT_MARKER, mUserData, &markerPosition); } while (newPosCount > 0) { size_t temp = newPosition.value(); // FIXME size_t != uint32_t mCbf(EVENT_NEW_POS, mUserData, &temp); newPosition += updatePeriod; newPosCount--; } if (mObservedSequence != sequence) { mObservedSequence = sequence; mCbf(EVENT_NEW_IAUDIORECORD, mUserData, NULL); } // if inactive, then don't run me again until re-started if (!active) { return NS_INACTIVE; } // Compute the estimated time until the next timed event (position, markers) uint32_t minFrames = ~0; if (!markerReached && position < markerPosition) { minFrames = (markerPosition - position).value(); } if (updatePeriod > 0) { uint32_t remaining = (newPosition - position).value(); if (remaining < minFrames) { minFrames = remaining; } } // If > 0, poll periodically to recover from a stuck server. A good value is 2. static const uint32_t kPoll = 0; if (kPoll > 0 && mTransfer == TRANSFER_CALLBACK && kPoll * notificationFrames < minFrames) { minFrames = kPoll * notificationFrames; } // Convert frame units to time units nsecs_t ns = NS_WHENEVER; if (minFrames != (uint32_t) ~0) { // This "fudge factor" avoids soaking CPU, and compensates for late progress by server static const nsecs_t kFudgeNs = 10000000LL; // 10 ms ns = ((minFrames * 1000000000LL) / mSampleRate) + kFudgeNs; } // If not supplying data by EVENT_MORE_DATA, then we're done if (mTransfer != TRANSFER_CALLBACK) { return ns; } struct timespec timeout; const struct timespec *requested = &ClientProxy::kForever; if (ns != NS_WHENEVER) { timeout.tv_sec = ns / 1000000000LL; timeout.tv_nsec = ns % 1000000000LL; ALOGV("timeout %ld.%03d", timeout.tv_sec, (int) timeout.tv_nsec / 1000000); requested = &timeout; } size_t readFrames = 0; while (mRemainingFrames > 0) { Buffer audioBuffer; audioBuffer.frameCount = mRemainingFrames; size_t nonContig; status_t err = obtainBuffer(&audioBuffer, requested, NULL, &nonContig); LOG_ALWAYS_FATAL_IF((err != NO_ERROR) != (audioBuffer.frameCount == 0), "obtainBuffer() err=%d frameCount=%zu", err, audioBuffer.frameCount); requested = &ClientProxy::kNonBlocking; size_t avail = audioBuffer.frameCount + nonContig; ALOGV("obtainBuffer(%u) returned %zu = %zu + %zu err %d", mRemainingFrames, avail, audioBuffer.frameCount, nonContig, err); if (err != NO_ERROR) { if (err == TIMED_OUT || err == WOULD_BLOCK || err == -EINTR) { break; } ALOGE("Error %d obtaining an audio buffer, giving up.", err); return NS_NEVER; } if (mRetryOnPartialBuffer) { mRetryOnPartialBuffer = false; if (avail < mRemainingFrames) { int64_t myns = ((mRemainingFrames - avail) * 1100000000LL) / mSampleRate; if (ns < 0 || myns < ns) { ns = myns; } return ns; } } size_t reqSize = audioBuffer.size; mCbf(EVENT_MORE_DATA, mUserData, &audioBuffer); size_t readSize = audioBuffer.size; // Sanity check on returned size if (ssize_t(readSize) < 0 || readSize > reqSize) { ALOGE("EVENT_MORE_DATA requested %zu bytes but callback returned %zd bytes", reqSize, ssize_t(readSize)); return NS_NEVER; } if (readSize == 0) { // The callback is done consuming buffers // Keep this thread going to handle timed events and // still try to provide more data in intervals of WAIT_PERIOD_MS // but don't just loop and block the CPU, so wait return WAIT_PERIOD_MS * 1000000LL; } size_t releasedFrames = readSize / mFrameSize; audioBuffer.frameCount = releasedFrames; mRemainingFrames -= releasedFrames; if (misalignment >= releasedFrames) { misalignment -= releasedFrames; } else { misalignment = 0; } releaseBuffer(&audioBuffer); readFrames += releasedFrames; // FIXME here is where we would repeat EVENT_MORE_DATA again on same advanced buffer // if callback doesn't like to accept the full chunk if (readSize < reqSize) { continue; } // There could be enough non-contiguous frames available to satisfy the remaining request if (mRemainingFrames <= nonContig) { continue; } #if 0 // This heuristic tries to collapse a series of EVENT_MORE_DATA that would total to a // sum <= notificationFrames. It replaces that series by at most two EVENT_MORE_DATA // that total to a sum == notificationFrames. if (0 < misalignment && misalignment <= mRemainingFrames) { mRemainingFrames = misalignment; return (mRemainingFrames * 1100000000LL) / mSampleRate; } #endif } if (readFrames > 0) { AutoMutex lock(mLock); mFramesRead += readFrames; // mFramesReadTime = systemTime(SYSTEM_TIME_MONOTONIC); // not provided at this time. } mRemainingFrames = notificationFrames; mRetryOnPartialBuffer = true; // A lot has transpired since ns was calculated, so run again immediately and re-calculate return 0; }