1 /* 2 * Copyright (C) 2012 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 // <IMPORTANT_WARNING> 18 // Design rules for threadLoop() are given in the comments at section "Fast mixer thread" of 19 // StateQueue.h. In particular, avoid library and system calls except at well-known points. 20 // The design rules are only for threadLoop(), and don't apply to FastMixerDumpState methods. 21 // </IMPORTANT_WARNING> 22 23 #define LOG_TAG "FastMixer" 24 //#define LOG_NDEBUG 0 25 26 #define ATRACE_TAG ATRACE_TAG_AUDIO 27 28 #include "Configuration.h" 29 #include <time.h> 30 #include <utils/Debug.h> 31 #include <utils/Log.h> 32 #include <utils/Trace.h> 33 #include <system/audio.h> 34 #ifdef FAST_THREAD_STATISTICS 35 #include <cpustats/CentralTendencyStatistics.h> 36 #ifdef CPU_FREQUENCY_STATISTICS 37 #include <cpustats/ThreadCpuUsage.h> 38 #endif 39 #endif 40 #include <audio_utils/mono_blend.h> 41 #include <audio_utils/format.h> 42 #include <media/AudioMixer.h> 43 #include "FastMixer.h" 44 #include "TypedLogger.h" 45 46 namespace android { 47 48 /*static*/ const FastMixerState FastMixer::sInitial; 49 50 FastMixer::FastMixer() : FastThread("cycle_ms", "load_us"), 51 // mFastTrackNames 52 // mGenerations 53 mOutputSink(NULL), 54 mOutputSinkGen(0), 55 mMixer(NULL), 56 mSinkBuffer(NULL), 57 mSinkBufferSize(0), 58 mSinkChannelCount(FCC_2), 59 mMixerBuffer(NULL), 60 mMixerBufferSize(0), 61 mMixerBufferFormat(AUDIO_FORMAT_PCM_16_BIT), 62 mMixerBufferState(UNDEFINED), 63 mFormat(Format_Invalid), 64 mSampleRate(0), 65 mFastTracksGen(0), 66 mTotalNativeFramesWritten(0), 67 // timestamp 68 mNativeFramesWrittenButNotPresented(0), // the = 0 is to silence the compiler 69 mMasterMono(false) 70 { 71 // FIXME pass sInitial as parameter to base class constructor, and make it static local 72 mPrevious = &sInitial; 73 mCurrent = &sInitial; 74 75 mDummyDumpState = &mDummyFastMixerDumpState; 76 // TODO: Add channel mask to NBAIO_Format. 77 // We assume that the channel mask must be a valid positional channel mask. 78 mSinkChannelMask = audio_channel_out_mask_from_count(mSinkChannelCount); 79 80 unsigned i; 81 for (i = 0; i < FastMixerState::sMaxFastTracks; ++i) { 82 mFastTrackNames[i] = -1; 83 mGenerations[i] = 0; 84 } 85 #ifdef FAST_THREAD_STATISTICS 86 mOldLoad.tv_sec = 0; 87 mOldLoad.tv_nsec = 0; 88 #endif 89 } 90 91 FastMixer::~FastMixer() 92 { 93 } 94 95 FastMixerStateQueue* FastMixer::sq() 96 { 97 return &mSQ; 98 } 99 100 const FastThreadState *FastMixer::poll() 101 { 102 return mSQ.poll(); 103 } 104 105 void FastMixer::setNBLogWriter(NBLog::Writer *logWriter) 106 { 107 // FIXME If mMixer is set or changed prior to this, we don't inform correctly. 108 // Should cache logWriter and re-apply it at the assignment to mMixer. 109 if (mMixer != NULL) { 110 mMixer->setNBLogWriter(logWriter); 111 } 112 } 113 114 void FastMixer::onIdle() 115 { 116 mPreIdle = *(const FastMixerState *)mCurrent; 117 mCurrent = &mPreIdle; 118 } 119 120 void FastMixer::onExit() 121 { 122 delete mMixer; 123 free(mMixerBuffer); 124 free(mSinkBuffer); 125 } 126 127 bool FastMixer::isSubClassCommand(FastThreadState::Command command) 128 { 129 switch ((FastMixerState::Command) command) { 130 case FastMixerState::MIX: 131 case FastMixerState::WRITE: 132 case FastMixerState::MIX_WRITE: 133 return true; 134 default: 135 return false; 136 } 137 } 138 139 void FastMixer::onStateChange() 140 { 141 // log that audio was turned on/off 142 LOG_AUDIO_STATE(); 143 const FastMixerState * const current = (const FastMixerState *) mCurrent; 144 const FastMixerState * const previous = (const FastMixerState *) mPrevious; 145 FastMixerDumpState * const dumpState = (FastMixerDumpState *) mDumpState; 146 const size_t frameCount = current->mFrameCount; 147 148 // update boottime offset, in case it has changed 149 mTimestamp.mTimebaseOffset[ExtendedTimestamp::TIMEBASE_BOOTTIME] = 150 mBoottimeOffset.load(); 151 152 // handle state change here, but since we want to diff the state, 153 // we're prepared for previous == &sInitial the first time through 154 unsigned previousTrackMask; 155 156 // check for change in output HAL configuration 157 NBAIO_Format previousFormat = mFormat; 158 if (current->mOutputSinkGen != mOutputSinkGen) { 159 mOutputSink = current->mOutputSink; 160 mOutputSinkGen = current->mOutputSinkGen; 161 if (mOutputSink == NULL) { 162 mFormat = Format_Invalid; 163 mSampleRate = 0; 164 mSinkChannelCount = 0; 165 mSinkChannelMask = AUDIO_CHANNEL_NONE; 166 } else { 167 mFormat = mOutputSink->format(); 168 mSampleRate = Format_sampleRate(mFormat); 169 mSinkChannelCount = Format_channelCount(mFormat); 170 LOG_ALWAYS_FATAL_IF(mSinkChannelCount > AudioMixer::MAX_NUM_CHANNELS); 171 172 // TODO: Add channel mask to NBAIO_Format 173 // We assume that the channel mask must be a valid positional channel mask. 174 mSinkChannelMask = audio_channel_out_mask_from_count(mSinkChannelCount); 175 } 176 dumpState->mSampleRate = mSampleRate; 177 } 178 179 if ((!Format_isEqual(mFormat, previousFormat)) || (frameCount != previous->mFrameCount)) { 180 // FIXME to avoid priority inversion, don't delete here 181 delete mMixer; 182 mMixer = NULL; 183 free(mMixerBuffer); 184 mMixerBuffer = NULL; 185 free(mSinkBuffer); 186 mSinkBuffer = NULL; 187 if (frameCount > 0 && mSampleRate > 0) { 188 // The mixer produces either 16 bit PCM or float output, select 189 // float output if the HAL supports higher than 16 bit precision. 190 mMixerBufferFormat = mFormat.mFormat == AUDIO_FORMAT_PCM_16_BIT ? 191 AUDIO_FORMAT_PCM_16_BIT : AUDIO_FORMAT_PCM_FLOAT; 192 // FIXME new may block for unbounded time at internal mutex of the heap 193 // implementation; it would be better to have normal mixer allocate for us 194 // to avoid blocking here and to prevent possible priority inversion 195 mMixer = new AudioMixer(frameCount, mSampleRate, FastMixerState::sMaxFastTracks); 196 // FIXME See the other FIXME at FastMixer::setNBLogWriter() 197 const size_t mixerFrameSize = mSinkChannelCount 198 * audio_bytes_per_sample(mMixerBufferFormat); 199 mMixerBufferSize = mixerFrameSize * frameCount; 200 (void)posix_memalign(&mMixerBuffer, 32, mMixerBufferSize); 201 const size_t sinkFrameSize = mSinkChannelCount 202 * audio_bytes_per_sample(mFormat.mFormat); 203 if (sinkFrameSize > mixerFrameSize) { // need a sink buffer 204 mSinkBufferSize = sinkFrameSize * frameCount; 205 (void)posix_memalign(&mSinkBuffer, 32, mSinkBufferSize); 206 } 207 mPeriodNs = (frameCount * 1000000000LL) / mSampleRate; // 1.00 208 mUnderrunNs = (frameCount * 1750000000LL) / mSampleRate; // 1.75 209 mOverrunNs = (frameCount * 500000000LL) / mSampleRate; // 0.50 210 mForceNs = (frameCount * 950000000LL) / mSampleRate; // 0.95 211 mWarmupNsMin = (frameCount * 750000000LL) / mSampleRate; // 0.75 212 mWarmupNsMax = (frameCount * 1250000000LL) / mSampleRate; // 1.25 213 } else { 214 mPeriodNs = 0; 215 mUnderrunNs = 0; 216 mOverrunNs = 0; 217 mForceNs = 0; 218 mWarmupNsMin = 0; 219 mWarmupNsMax = LONG_MAX; 220 } 221 mMixerBufferState = UNDEFINED; 222 #if !LOG_NDEBUG 223 for (unsigned i = 0; i < FastMixerState::sMaxFastTracks; ++i) { 224 mFastTrackNames[i] = -1; 225 } 226 #endif 227 // we need to reconfigure all active tracks 228 previousTrackMask = 0; 229 mFastTracksGen = current->mFastTracksGen - 1; 230 dumpState->mFrameCount = frameCount; 231 } else { 232 previousTrackMask = previous->mTrackMask; 233 } 234 235 // check for change in active track set 236 const unsigned currentTrackMask = current->mTrackMask; 237 dumpState->mTrackMask = currentTrackMask; 238 if (current->mFastTracksGen != mFastTracksGen) { 239 ALOG_ASSERT(mMixerBuffer != NULL); 240 int name; 241 242 // process removed tracks first to avoid running out of track names 243 unsigned removedTracks = previousTrackMask & ~currentTrackMask; 244 while (removedTracks != 0) { 245 int i = __builtin_ctz(removedTracks); 246 removedTracks &= ~(1 << i); 247 const FastTrack* fastTrack = ¤t->mFastTracks[i]; 248 ALOG_ASSERT(fastTrack->mBufferProvider == NULL); 249 if (mMixer != NULL) { 250 name = mFastTrackNames[i]; 251 ALOG_ASSERT(name >= 0); 252 mMixer->deleteTrackName(name); 253 } 254 #if !LOG_NDEBUG 255 mFastTrackNames[i] = -1; 256 #endif 257 // don't reset track dump state, since other side is ignoring it 258 mGenerations[i] = fastTrack->mGeneration; 259 } 260 261 // now process added tracks 262 unsigned addedTracks = currentTrackMask & ~previousTrackMask; 263 while (addedTracks != 0) { 264 int i = __builtin_ctz(addedTracks); 265 addedTracks &= ~(1 << i); 266 const FastTrack* fastTrack = ¤t->mFastTracks[i]; 267 AudioBufferProvider *bufferProvider = fastTrack->mBufferProvider; 268 ALOG_ASSERT(bufferProvider != NULL && mFastTrackNames[i] == -1); 269 if (mMixer != NULL) { 270 name = mMixer->getTrackName(fastTrack->mChannelMask, 271 fastTrack->mFormat, AUDIO_SESSION_OUTPUT_MIX); 272 ALOG_ASSERT(name >= 0); 273 mFastTrackNames[i] = name; 274 mMixer->setBufferProvider(name, bufferProvider); 275 mMixer->setParameter(name, AudioMixer::TRACK, AudioMixer::MAIN_BUFFER, 276 (void *)mMixerBuffer); 277 // newly allocated track names default to full scale volume 278 mMixer->setParameter( 279 name, 280 AudioMixer::TRACK, 281 AudioMixer::MIXER_FORMAT, (void *)mMixerBufferFormat); 282 mMixer->setParameter(name, AudioMixer::TRACK, AudioMixer::FORMAT, 283 (void *)(uintptr_t)fastTrack->mFormat); 284 mMixer->setParameter(name, AudioMixer::TRACK, AudioMixer::CHANNEL_MASK, 285 (void *)(uintptr_t)fastTrack->mChannelMask); 286 mMixer->setParameter(name, AudioMixer::TRACK, AudioMixer::MIXER_CHANNEL_MASK, 287 (void *)(uintptr_t)mSinkChannelMask); 288 mMixer->enable(name); 289 } 290 mGenerations[i] = fastTrack->mGeneration; 291 } 292 293 // finally process (potentially) modified tracks; these use the same slot 294 // but may have a different buffer provider or volume provider 295 unsigned modifiedTracks = currentTrackMask & previousTrackMask; 296 while (modifiedTracks != 0) { 297 int i = __builtin_ctz(modifiedTracks); 298 modifiedTracks &= ~(1 << i); 299 const FastTrack* fastTrack = ¤t->mFastTracks[i]; 300 if (fastTrack->mGeneration != mGenerations[i]) { 301 // this track was actually modified 302 AudioBufferProvider *bufferProvider = fastTrack->mBufferProvider; 303 ALOG_ASSERT(bufferProvider != NULL); 304 if (mMixer != NULL) { 305 name = mFastTrackNames[i]; 306 ALOG_ASSERT(name >= 0); 307 mMixer->setBufferProvider(name, bufferProvider); 308 if (fastTrack->mVolumeProvider == NULL) { 309 float f = AudioMixer::UNITY_GAIN_FLOAT; 310 mMixer->setParameter(name, AudioMixer::VOLUME, AudioMixer::VOLUME0, &f); 311 mMixer->setParameter(name, AudioMixer::VOLUME, AudioMixer::VOLUME1, &f); 312 } 313 mMixer->setParameter(name, AudioMixer::RESAMPLE, 314 AudioMixer::REMOVE, NULL); 315 mMixer->setParameter( 316 name, 317 AudioMixer::TRACK, 318 AudioMixer::MIXER_FORMAT, (void *)mMixerBufferFormat); 319 mMixer->setParameter(name, AudioMixer::TRACK, AudioMixer::FORMAT, 320 (void *)(uintptr_t)fastTrack->mFormat); 321 mMixer->setParameter(name, AudioMixer::TRACK, AudioMixer::CHANNEL_MASK, 322 (void *)(uintptr_t)fastTrack->mChannelMask); 323 mMixer->setParameter(name, AudioMixer::TRACK, AudioMixer::MIXER_CHANNEL_MASK, 324 (void *)(uintptr_t)mSinkChannelMask); 325 // already enabled 326 } 327 mGenerations[i] = fastTrack->mGeneration; 328 } 329 } 330 331 mFastTracksGen = current->mFastTracksGen; 332 333 dumpState->mNumTracks = popcount(currentTrackMask); 334 } 335 } 336 337 void FastMixer::onWork() 338 { 339 LOG_HIST_TS(); 340 const FastMixerState * const current = (const FastMixerState *) mCurrent; 341 FastMixerDumpState * const dumpState = (FastMixerDumpState *) mDumpState; 342 const FastMixerState::Command command = mCommand; 343 const size_t frameCount = current->mFrameCount; 344 345 if ((command & FastMixerState::MIX) && (mMixer != NULL) && mIsWarm) { 346 ALOG_ASSERT(mMixerBuffer != NULL); 347 348 // AudioMixer::mState.enabledTracks is undefined if mState.hook == process__validate, 349 // so we keep a side copy of enabledTracks 350 bool anyEnabledTracks = false; 351 352 // for each track, update volume and check for underrun 353 unsigned currentTrackMask = current->mTrackMask; 354 while (currentTrackMask != 0) { 355 int i = __builtin_ctz(currentTrackMask); 356 currentTrackMask &= ~(1 << i); 357 const FastTrack* fastTrack = ¤t->mFastTracks[i]; 358 359 const int64_t trackFramesWrittenButNotPresented = 360 mNativeFramesWrittenButNotPresented; 361 const int64_t trackFramesWritten = fastTrack->mBufferProvider->framesReleased(); 362 ExtendedTimestamp perTrackTimestamp(mTimestamp); 363 364 // Can't provide an ExtendedTimestamp before first frame presented. 365 // Also, timestamp may not go to very last frame on stop(). 366 if (trackFramesWritten >= trackFramesWrittenButNotPresented && 367 perTrackTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] > 0) { 368 perTrackTimestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL] = 369 trackFramesWritten - trackFramesWrittenButNotPresented; 370 } else { 371 perTrackTimestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL] = 0; 372 perTrackTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] = -1; 373 } 374 perTrackTimestamp.mPosition[ExtendedTimestamp::LOCATION_SERVER] = trackFramesWritten; 375 fastTrack->mBufferProvider->onTimestamp(perTrackTimestamp); 376 377 int name = mFastTrackNames[i]; 378 ALOG_ASSERT(name >= 0); 379 if (fastTrack->mVolumeProvider != NULL) { 380 gain_minifloat_packed_t vlr = fastTrack->mVolumeProvider->getVolumeLR(); 381 float vlf = float_from_gain(gain_minifloat_unpack_left(vlr)); 382 float vrf = float_from_gain(gain_minifloat_unpack_right(vlr)); 383 384 mMixer->setParameter(name, AudioMixer::VOLUME, AudioMixer::VOLUME0, &vlf); 385 mMixer->setParameter(name, AudioMixer::VOLUME, AudioMixer::VOLUME1, &vrf); 386 } 387 // FIXME The current implementation of framesReady() for fast tracks 388 // takes a tryLock, which can block 389 // up to 1 ms. If enough active tracks all blocked in sequence, this would result 390 // in the overall fast mix cycle being delayed. Should use a non-blocking FIFO. 391 size_t framesReady = fastTrack->mBufferProvider->framesReady(); 392 if (ATRACE_ENABLED()) { 393 // I wish we had formatted trace names 394 char traceName[16]; 395 strcpy(traceName, "fRdy"); 396 traceName[4] = i + (i < 10 ? '0' : 'A' - 10); 397 traceName[5] = '\0'; 398 ATRACE_INT(traceName, framesReady); 399 } 400 FastTrackDump *ftDump = &dumpState->mTracks[i]; 401 FastTrackUnderruns underruns = ftDump->mUnderruns; 402 if (framesReady < frameCount) { 403 if (framesReady == 0) { 404 underruns.mBitFields.mEmpty++; 405 underruns.mBitFields.mMostRecent = UNDERRUN_EMPTY; 406 mMixer->disable(name); 407 } else { 408 // allow mixing partial buffer 409 underruns.mBitFields.mPartial++; 410 underruns.mBitFields.mMostRecent = UNDERRUN_PARTIAL; 411 mMixer->enable(name); 412 anyEnabledTracks = true; 413 } 414 } else { 415 underruns.mBitFields.mFull++; 416 underruns.mBitFields.mMostRecent = UNDERRUN_FULL; 417 mMixer->enable(name); 418 anyEnabledTracks = true; 419 } 420 ftDump->mUnderruns = underruns; 421 ftDump->mFramesReady = framesReady; 422 ftDump->mFramesWritten = trackFramesWritten; 423 } 424 425 if (anyEnabledTracks) { 426 // process() is CPU-bound 427 mMixer->process(); 428 mMixerBufferState = MIXED; 429 } else if (mMixerBufferState != ZEROED) { 430 mMixerBufferState = UNDEFINED; 431 } 432 433 } else if (mMixerBufferState == MIXED) { 434 mMixerBufferState = UNDEFINED; 435 } 436 //bool didFullWrite = false; // dumpsys could display a count of partial writes 437 if ((command & FastMixerState::WRITE) && (mOutputSink != NULL) && (mMixerBuffer != NULL)) { 438 if (mMixerBufferState == UNDEFINED) { 439 memset(mMixerBuffer, 0, mMixerBufferSize); 440 mMixerBufferState = ZEROED; 441 } 442 443 if (mMasterMono.load()) { // memory_order_seq_cst 444 mono_blend(mMixerBuffer, mMixerBufferFormat, Format_channelCount(mFormat), frameCount, 445 true /*limit*/); 446 } 447 // prepare the buffer used to write to sink 448 void *buffer = mSinkBuffer != NULL ? mSinkBuffer : mMixerBuffer; 449 if (mFormat.mFormat != mMixerBufferFormat) { // sink format not the same as mixer format 450 memcpy_by_audio_format(buffer, mFormat.mFormat, mMixerBuffer, mMixerBufferFormat, 451 frameCount * Format_channelCount(mFormat)); 452 } 453 // if non-NULL, then duplicate write() to this non-blocking sink 454 NBAIO_Sink* teeSink; 455 if ((teeSink = current->mTeeSink) != NULL) { 456 (void) teeSink->write(buffer, frameCount); 457 } 458 // FIXME write() is non-blocking and lock-free for a properly implemented NBAIO sink, 459 // but this code should be modified to handle both non-blocking and blocking sinks 460 dumpState->mWriteSequence++; 461 ATRACE_BEGIN("write"); 462 ssize_t framesWritten = mOutputSink->write(buffer, frameCount); 463 ATRACE_END(); 464 dumpState->mWriteSequence++; 465 if (framesWritten >= 0) { 466 ALOG_ASSERT((size_t) framesWritten <= frameCount); 467 mTotalNativeFramesWritten += framesWritten; 468 dumpState->mFramesWritten = mTotalNativeFramesWritten; 469 //if ((size_t) framesWritten == frameCount) { 470 // didFullWrite = true; 471 //} 472 } else { 473 dumpState->mWriteErrors++; 474 } 475 mAttemptedWrite = true; 476 // FIXME count # of writes blocked excessively, CPU usage, etc. for dump 477 478 ExtendedTimestamp timestamp; // local 479 status_t status = mOutputSink->getTimestamp(timestamp); 480 if (status == NO_ERROR) { 481 const int64_t totalNativeFramesPresented = 482 timestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL]; 483 if (totalNativeFramesPresented <= mTotalNativeFramesWritten) { 484 mNativeFramesWrittenButNotPresented = 485 mTotalNativeFramesWritten - totalNativeFramesPresented; 486 mTimestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL] = 487 timestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL]; 488 mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] = 489 timestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL]; 490 } else { 491 // HAL reported that more frames were presented than were written 492 mNativeFramesWrittenButNotPresented = 0; 493 status = INVALID_OPERATION; 494 } 495 } 496 if (status == NO_ERROR) { 497 mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_SERVER] = 498 mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL]; 499 } else { 500 // fetch server time if we can't get timestamp 501 mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_SERVER] = 502 systemTime(SYSTEM_TIME_MONOTONIC); 503 // clear out kernel cached position as this may get rapidly stale 504 // if we never get a new valid timestamp 505 mTimestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL] = 0; 506 mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] = -1; 507 } 508 } 509 } 510 511 } // namespace android 512