blob: be59ca011d12e00413d5c278ccaff1661fd2e1bd [file] [log] [blame]
Glenn Kasten99e53b82012-01-19 08:59:58 -08001/*
Mathias Agopian65ab4712010-07-14 17:59:35 -07002**
3** Copyright 2007, The Android Open Source Project
4**
5** Licensed under the Apache License, Version 2.0 (the "License");
6** you may not use this file except in compliance with the License.
7** You may obtain a copy of the License at
8**
9** http://www.apache.org/licenses/LICENSE-2.0
10**
11** Unless required by applicable law or agreed to in writing, software
12** distributed under the License is distributed on an "AS IS" BASIS,
13** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14** See the License for the specific language governing permissions and
15** limitations under the License.
16*/
17
18
19#define LOG_TAG "AudioFlinger"
20//#define LOG_NDEBUG 0
21
22#include <math.h>
23#include <signal.h>
24#include <sys/time.h>
25#include <sys/resource.h>
26
Gloria Wang9ee159b2011-02-24 14:51:45 -080027#include <binder/IPCThreadState.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070028#include <binder/IServiceManager.h>
29#include <utils/Log.h>
Glenn Kastend8e6fd32012-05-07 11:07:57 -070030#include <utils/Trace.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070031#include <binder/Parcel.h>
32#include <binder/IPCThreadState.h>
33#include <utils/String16.h>
34#include <utils/threads.h>
Eric Laurent38ccae22011-03-28 18:37:07 -070035#include <utils/Atomic.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070036
Dima Zavinfce7a472011-04-19 22:30:36 -070037#include <cutils/bitops.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070038#include <cutils/properties.h>
Glenn Kastenf6b16782011-12-15 09:51:17 -080039#include <cutils/compiler.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070040
Glenn Kastend3cee2f2012-03-13 17:55:35 -070041#undef ADD_BATTERY_DATA
42
43#ifdef ADD_BATTERY_DATA
Gloria Wang9ee159b2011-02-24 14:51:45 -080044#include <media/IMediaPlayerService.h>
Glenn Kasten25b248e2012-01-03 15:28:29 -080045#include <media/IMediaDeathNotifier.h>
Glenn Kastend3cee2f2012-03-13 17:55:35 -070046#endif
Mathias Agopian65ab4712010-07-14 17:59:35 -070047
48#include <private/media/AudioTrackShared.h>
49#include <private/media/AudioEffectShared.h>
Dima Zavinfce7a472011-04-19 22:30:36 -070050
Dima Zavin64760242011-05-11 14:15:23 -070051#include <system/audio.h>
Dima Zavin7394a4f2011-06-13 18:16:26 -070052#include <hardware/audio.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070053
54#include "AudioMixer.h"
55#include "AudioFlinger.h"
Glenn Kasten44deb052012-02-05 18:09:08 -080056#include "ServiceUtilities.h"
Mathias Agopian65ab4712010-07-14 17:59:35 -070057
Mathias Agopian65ab4712010-07-14 17:59:35 -070058#include <media/EffectsFactoryApi.h>
Eric Laurent6d8b6942011-06-24 07:01:31 -070059#include <audio_effects/effect_visualizer.h>
Eric Laurent59bd0da2011-08-01 09:52:20 -070060#include <audio_effects/effect_ns.h>
61#include <audio_effects/effect_aec.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070062
Glenn Kasten3b21c502011-12-15 09:52:39 -080063#include <audio_utils/primitives.h>
64
Eric Laurentfeb0db62011-07-22 09:04:31 -070065#include <powermanager/PowerManager.h>
Glenn Kasten190a46f2012-03-06 11:27:10 -080066
Glenn Kasten4d8d0c32011-07-08 15:26:12 -070067// #define DEBUG_CPU_USAGE 10 // log statistics every n wall clock seconds
Glenn Kasten190a46f2012-03-06 11:27:10 -080068#ifdef DEBUG_CPU_USAGE
69#include <cpustats/CentralTendencyStatistics.h>
70#include <cpustats/ThreadCpuUsage.h>
71#endif
Glenn Kasten4d8d0c32011-07-08 15:26:12 -070072
John Grossman4ff14ba2012-02-08 16:37:41 -080073#include <common_time/cc_helper.h>
74#include <common_time/local_clock.h>
75
Glenn Kasten58912562012-04-03 10:45:00 -070076#include "FastMixer.h"
77
78// NBAIO implementations
79#include "AudioStreamOutSink.h"
80#include "MonoPipe.h"
81#include "MonoPipeReader.h"
Glenn Kastenfbae5da2012-05-21 09:17:20 -070082#include "Pipe.h"
83#include "PipeReader.h"
Glenn Kasten58912562012-04-03 10:45:00 -070084#include "SourceAudioBufferProvider.h"
85
Glenn Kasten1dc28b72012-04-24 10:01:03 -070086#ifdef HAVE_REQUEST_PRIORITY
87#include "SchedulingPolicyService.h"
88#endif
89
Glenn Kasten58912562012-04-03 10:45:00 -070090#ifdef SOAKER
91#include "Soaker.h"
92#endif
93
Mathias Agopian65ab4712010-07-14 17:59:35 -070094// ----------------------------------------------------------------------------
Mathias Agopian65ab4712010-07-14 17:59:35 -070095
John Grossman1c345192012-03-27 14:00:17 -070096// Note: the following macro is used for extremely verbose logging message. In
97// order to run with ALOG_ASSERT turned on, we need to have LOG_NDEBUG set to
98// 0; but one side effect of this is to turn all LOGV's as well. Some messages
99// are so verbose that we want to suppress them even when we have ALOG_ASSERT
100// turned on. Do not uncomment the #def below unless you really know what you
101// are doing and want to see all of the extremely verbose messages.
102//#define VERY_VERY_VERBOSE_LOGGING
103#ifdef VERY_VERY_VERBOSE_LOGGING
104#define ALOGVV ALOGV
105#else
106#define ALOGVV(a...) do { } while(0)
107#endif
Eric Laurentde070132010-07-13 04:45:46 -0700108
Mathias Agopian65ab4712010-07-14 17:59:35 -0700109namespace android {
110
Glenn Kastenec1d6b52011-12-12 09:04:45 -0800111static const char kDeadlockedString[] = "AudioFlinger may be deadlocked\n";
112static const char kHardwareLockedString[] = "Hardware lock is taken\n";
Mathias Agopian65ab4712010-07-14 17:59:35 -0700113
Mathias Agopian65ab4712010-07-14 17:59:35 -0700114static const float MAX_GAIN = 4096.0f;
Glenn Kastenb1cf75c2012-01-17 12:20:54 -0800115static const uint32_t MAX_GAIN_INT = 0x1000;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700116
117// retry counts for buffer fill timeout
118// 50 * ~20msecs = 1 second
119static const int8_t kMaxTrackRetries = 50;
120static const int8_t kMaxTrackStartupRetries = 50;
121// allow less retry attempts on direct output thread.
122// direct outputs can be a scarce resource in audio hardware and should
123// be released as quickly as possible.
124static const int8_t kMaxTrackRetriesDirect = 2;
125
126static const int kDumpLockRetries = 50;
Glenn Kasten7dede872011-12-13 11:04:14 -0800127static const int kDumpLockSleepUs = 20000;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700128
Glenn Kasten7dede872011-12-13 11:04:14 -0800129// don't warn about blocked writes or record buffer overflows more often than this
130static const nsecs_t kWarningThrottleNs = seconds(5);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700131
Eric Laurent7c7f10b2011-06-17 21:29:58 -0700132// RecordThread loop sleep time upon application overrun or audio HAL read error
133static const int kRecordThreadSleepUs = 5000;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700134
Glenn Kasten7dede872011-12-13 11:04:14 -0800135// maximum time to wait for setParameters to complete
136static const nsecs_t kSetParametersTimeoutNs = seconds(2);
Eric Laurent60cd0a02011-09-13 11:40:21 -0700137
Eric Laurent7cafbb32011-11-22 18:50:29 -0800138// minimum sleep time for the mixer thread loop when tracks are active but in underrun
139static const uint32_t kMinThreadSleepTimeUs = 5000;
140// maximum divider applied to the active sleep time in the mixer thread loop
141static const uint32_t kMaxThreadSleepTimeShift = 2;
142
Glenn Kasten58912562012-04-03 10:45:00 -0700143// minimum normal mix buffer size, expressed in milliseconds rather than frames
144static const uint32_t kMinNormalMixBufferSizeMs = 20;
Glenn Kasten4adcede2012-05-14 12:26:02 -0700145// maximum normal mix buffer size
146static const uint32_t kMaxNormalMixBufferSizeMs = 24;
Glenn Kasten58912562012-04-03 10:45:00 -0700147
John Grossman4ff14ba2012-02-08 16:37:41 -0800148nsecs_t AudioFlinger::mStandbyTimeInNsecs = kDefaultStandbyTimeInNsecs;
Eric Laurent7cafbb32011-11-22 18:50:29 -0800149
Glenn Kasten300a2ee2012-04-25 13:47:36 -0700150// Whether to use fast mixer
151static const enum {
152 FastMixer_Never, // never initialize or use: for debugging only
153 FastMixer_Always, // always initialize and use, even if not needed: for debugging only
154 // normal mixer multiplier is 1
155 FastMixer_Static, // initialize if needed, then use all the time if initialized,
Glenn Kasten4adcede2012-05-14 12:26:02 -0700156 // multiplier is calculated based on min & max normal mixer buffer size
Glenn Kasten300a2ee2012-04-25 13:47:36 -0700157 FastMixer_Dynamic, // initialize if needed, then use dynamically depending on track load,
Glenn Kasten4adcede2012-05-14 12:26:02 -0700158 // multiplier is calculated based on min & max normal mixer buffer size
Glenn Kasten300a2ee2012-04-25 13:47:36 -0700159 // FIXME for FastMixer_Dynamic:
160 // Supporting this option will require fixing HALs that can't handle large writes.
161 // For example, one HAL implementation returns an error from a large write,
162 // and another HAL implementation corrupts memory, possibly in the sample rate converter.
163 // We could either fix the HAL implementations, or provide a wrapper that breaks
164 // up large writes into smaller ones, and the wrapper would need to deal with scheduler.
165} kUseFastMixer = FastMixer_Static;
166
Glenn Kasten28ed2f92012-06-07 10:17:54 -0700167static uint32_t gScreenState; // incremented by 2 when screen state changes, bit 0 == 1 means "off"
168 // AudioFlinger::setParameters() updates, other threads read w/o lock
169
Mathias Agopian65ab4712010-07-14 17:59:35 -0700170// ----------------------------------------------------------------------------
171
Glenn Kastend3cee2f2012-03-13 17:55:35 -0700172#ifdef ADD_BATTERY_DATA
Gloria Wang9ee159b2011-02-24 14:51:45 -0800173// To collect the amplifier usage
174static void addBatteryData(uint32_t params) {
Glenn Kasten25b248e2012-01-03 15:28:29 -0800175 sp<IMediaPlayerService> service = IMediaDeathNotifier::getMediaPlayerService();
176 if (service == NULL) {
177 // it already logged
Gloria Wang9ee159b2011-02-24 14:51:45 -0800178 return;
179 }
180
181 service->addBatteryData(params);
182}
Glenn Kastend3cee2f2012-03-13 17:55:35 -0700183#endif
Gloria Wang9ee159b2011-02-24 14:51:45 -0800184
Eric Laurentf7ffb8b2012-04-14 09:06:57 -0700185static int load_audio_interface(const char *if_name, audio_hw_device_t **dev)
Dima Zavin799a70e2011-04-18 16:57:27 -0700186{
Eric Laurentf7ffb8b2012-04-14 09:06:57 -0700187 const hw_module_t *mod;
Dima Zavin799a70e2011-04-18 16:57:27 -0700188 int rc;
189
Eric Laurentf7ffb8b2012-04-14 09:06:57 -0700190 rc = hw_get_module_by_class(AUDIO_HARDWARE_MODULE_ID, if_name, &mod);
191 ALOGE_IF(rc, "%s couldn't load audio hw module %s.%s (%s)", __func__,
192 AUDIO_HARDWARE_MODULE_ID, if_name, strerror(-rc));
193 if (rc) {
Dima Zavin799a70e2011-04-18 16:57:27 -0700194 goto out;
Eric Laurentf7ffb8b2012-04-14 09:06:57 -0700195 }
196 rc = audio_hw_device_open(mod, dev);
197 ALOGE_IF(rc, "%s couldn't open audio hw device in %s.%s (%s)", __func__,
198 AUDIO_HARDWARE_MODULE_ID, if_name, strerror(-rc));
199 if (rc) {
Dima Zavin799a70e2011-04-18 16:57:27 -0700200 goto out;
Eric Laurentf7ffb8b2012-04-14 09:06:57 -0700201 }
202 if ((*dev)->common.version != AUDIO_DEVICE_API_VERSION_CURRENT) {
203 ALOGE("%s wrong audio hw device version %04x", __func__, (*dev)->common.version);
204 rc = BAD_VALUE;
205 goto out;
206 }
Dima Zavin799a70e2011-04-18 16:57:27 -0700207 return 0;
208
209out:
Dima Zavin799a70e2011-04-18 16:57:27 -0700210 *dev = NULL;
211 return rc;
212}
213
Mathias Agopian65ab4712010-07-14 17:59:35 -0700214// ----------------------------------------------------------------------------
215
216AudioFlinger::AudioFlinger()
217 : BnAudioFlinger(),
John Grossman4ff14ba2012-02-08 16:37:41 -0800218 mPrimaryHardwareDev(NULL),
219 mHardwareStatus(AUDIO_HW_IDLE), // see also onFirstRef()
220 mMasterVolume(1.0f),
221 mMasterVolumeSupportLvl(MVS_NONE),
222 mMasterMute(false),
223 mNextUniqueId(1),
224 mMode(AUDIO_MODE_INVALID),
225 mBtNrecIsOff(false)
Mathias Agopian65ab4712010-07-14 17:59:35 -0700226{
Dima Zavin5a61d2f2011-04-19 19:04:32 -0700227}
228
229void AudioFlinger::onFirstRef()
230{
Dima Zavin799a70e2011-04-18 16:57:27 -0700231 int rc = 0;
Dima Zavinfce7a472011-04-19 22:30:36 -0700232
Eric Laurent93575202011-01-18 18:39:02 -0800233 Mutex::Autolock _l(mLock);
234
Dima Zavin799a70e2011-04-18 16:57:27 -0700235 /* TODO: move all this work into an Init() function */
John Grossman4ff14ba2012-02-08 16:37:41 -0800236 char val_str[PROPERTY_VALUE_MAX] = { 0 };
237 if (property_get("ro.audio.flinger_standbytime_ms", val_str, NULL) >= 0) {
238 uint32_t int_val;
239 if (1 == sscanf(val_str, "%u", &int_val)) {
240 mStandbyTimeInNsecs = milliseconds(int_val);
241 ALOGI("Using %u mSec as standby time.", int_val);
242 } else {
243 mStandbyTimeInNsecs = kDefaultStandbyTimeInNsecs;
244 ALOGI("Using default %u mSec as standby time.",
245 (uint32_t)(mStandbyTimeInNsecs / 1000000));
246 }
247 }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700248
Eric Laurenta4c5a552012-03-29 10:12:40 -0700249 mMode = AUDIO_MODE_NORMAL;
250 mMasterVolumeSW = 1.0;
251 mMasterVolume = 1.0;
John Grossman4ff14ba2012-02-08 16:37:41 -0800252 mHardwareStatus = AUDIO_HW_IDLE;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700253}
254
255AudioFlinger::~AudioFlinger()
256{
Dima Zavin799a70e2011-04-18 16:57:27 -0700257
Mathias Agopian65ab4712010-07-14 17:59:35 -0700258 while (!mRecordThreads.isEmpty()) {
259 // closeInput() will remove first entry from mRecordThreads
260 closeInput(mRecordThreads.keyAt(0));
261 }
262 while (!mPlaybackThreads.isEmpty()) {
263 // closeOutput() will remove first entry from mPlaybackThreads
264 closeOutput(mPlaybackThreads.keyAt(0));
265 }
Dima Zavin799a70e2011-04-18 16:57:27 -0700266
Glenn Kasten2b213bc2012-02-02 14:05:20 -0800267 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
268 // no mHardwareLock needed, as there are no other references to this
Eric Laurenta4c5a552012-03-29 10:12:40 -0700269 audio_hw_device_close(mAudioHwDevs.valueAt(i)->hwDevice());
270 delete mAudioHwDevs.valueAt(i);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700271 }
272}
273
Eric Laurenta4c5a552012-03-29 10:12:40 -0700274static const char * const audio_interfaces[] = {
275 AUDIO_HARDWARE_MODULE_ID_PRIMARY,
276 AUDIO_HARDWARE_MODULE_ID_A2DP,
277 AUDIO_HARDWARE_MODULE_ID_USB,
278};
279#define ARRAY_SIZE(x) (sizeof((x))/sizeof(((x)[0])))
280
281audio_hw_device_t* AudioFlinger::findSuitableHwDev_l(audio_module_handle_t module, uint32_t devices)
Dima Zavin799a70e2011-04-18 16:57:27 -0700282{
Eric Laurenta4c5a552012-03-29 10:12:40 -0700283 // if module is 0, the request comes from an old policy manager and we should load
284 // well known modules
285 if (module == 0) {
286 ALOGW("findSuitableHwDev_l() loading well know audio hw modules");
287 for (size_t i = 0; i < ARRAY_SIZE(audio_interfaces); i++) {
288 loadHwModule_l(audio_interfaces[i]);
289 }
290 } else {
291 // check a match for the requested module handle
292 AudioHwDevice *audioHwdevice = mAudioHwDevs.valueFor(module);
293 if (audioHwdevice != NULL) {
294 return audioHwdevice->hwDevice();
295 }
296 }
297 // then try to find a module supporting the requested device.
Dima Zavin799a70e2011-04-18 16:57:27 -0700298 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
Eric Laurenta4c5a552012-03-29 10:12:40 -0700299 audio_hw_device_t *dev = mAudioHwDevs.valueAt(i)->hwDevice();
Dima Zavin799a70e2011-04-18 16:57:27 -0700300 if ((dev->get_supported_devices(dev) & devices) == devices)
301 return dev;
302 }
Eric Laurenta4c5a552012-03-29 10:12:40 -0700303
Dima Zavin799a70e2011-04-18 16:57:27 -0700304 return NULL;
305}
Mathias Agopian65ab4712010-07-14 17:59:35 -0700306
307status_t AudioFlinger::dumpClients(int fd, const Vector<String16>& args)
308{
309 const size_t SIZE = 256;
310 char buffer[SIZE];
311 String8 result;
312
313 result.append("Clients:\n");
314 for (size_t i = 0; i < mClients.size(); ++i) {
Glenn Kasten77c11192012-01-25 14:27:41 -0800315 sp<Client> client = mClients.valueAt(i).promote();
316 if (client != 0) {
317 snprintf(buffer, SIZE, " pid: %d\n", client->pid());
318 result.append(buffer);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700319 }
320 }
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700321
322 result.append("Global session refs:\n");
Glenn Kasten012ca6b2012-03-06 11:22:01 -0800323 result.append(" session pid count\n");
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700324 for (size_t i = 0; i < mAudioSessionRefs.size(); i++) {
325 AudioSessionRef *r = mAudioSessionRefs[i];
Glenn Kasten012ca6b2012-03-06 11:22:01 -0800326 snprintf(buffer, SIZE, " %7d %3d %3d\n", r->mSessionid, r->mPid, r->mCnt);
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700327 result.append(buffer);
328 }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700329 write(fd, result.string(), result.size());
330 return NO_ERROR;
331}
332
333
334status_t AudioFlinger::dumpInternals(int fd, const Vector<String16>& args)
335{
336 const size_t SIZE = 256;
337 char buffer[SIZE];
338 String8 result;
Glenn Kastena4454b42012-01-04 11:02:33 -0800339 hardware_call_state hardwareStatus = mHardwareStatus;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700340
John Grossman4ff14ba2012-02-08 16:37:41 -0800341 snprintf(buffer, SIZE, "Hardware status: %d\n"
342 "Standby Time mSec: %u\n",
343 hardwareStatus,
344 (uint32_t)(mStandbyTimeInNsecs / 1000000));
Mathias Agopian65ab4712010-07-14 17:59:35 -0700345 result.append(buffer);
346 write(fd, result.string(), result.size());
347 return NO_ERROR;
348}
349
350status_t AudioFlinger::dumpPermissionDenial(int fd, const Vector<String16>& args)
351{
352 const size_t SIZE = 256;
353 char buffer[SIZE];
354 String8 result;
355 snprintf(buffer, SIZE, "Permission Denial: "
356 "can't dump AudioFlinger from pid=%d, uid=%d\n",
357 IPCThreadState::self()->getCallingPid(),
358 IPCThreadState::self()->getCallingUid());
359 result.append(buffer);
360 write(fd, result.string(), result.size());
361 return NO_ERROR;
362}
363
364static bool tryLock(Mutex& mutex)
365{
366 bool locked = false;
367 for (int i = 0; i < kDumpLockRetries; ++i) {
368 if (mutex.tryLock() == NO_ERROR) {
369 locked = true;
370 break;
371 }
Glenn Kasten7dede872011-12-13 11:04:14 -0800372 usleep(kDumpLockSleepUs);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700373 }
374 return locked;
375}
376
377status_t AudioFlinger::dump(int fd, const Vector<String16>& args)
378{
Glenn Kasten44deb052012-02-05 18:09:08 -0800379 if (!dumpAllowed()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -0700380 dumpPermissionDenial(fd, args);
381 } else {
382 // get state of hardware lock
383 bool hardwareLocked = tryLock(mHardwareLock);
384 if (!hardwareLocked) {
385 String8 result(kHardwareLockedString);
386 write(fd, result.string(), result.size());
387 } else {
388 mHardwareLock.unlock();
389 }
390
391 bool locked = tryLock(mLock);
392
393 // failed to lock - AudioFlinger is probably deadlocked
394 if (!locked) {
395 String8 result(kDeadlockedString);
396 write(fd, result.string(), result.size());
397 }
398
399 dumpClients(fd, args);
400 dumpInternals(fd, args);
401
402 // dump playback threads
403 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
404 mPlaybackThreads.valueAt(i)->dump(fd, args);
405 }
406
407 // dump record threads
408 for (size_t i = 0; i < mRecordThreads.size(); i++) {
409 mRecordThreads.valueAt(i)->dump(fd, args);
410 }
411
Dima Zavin799a70e2011-04-18 16:57:27 -0700412 // dump all hardware devs
413 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
Eric Laurenta4c5a552012-03-29 10:12:40 -0700414 audio_hw_device_t *dev = mAudioHwDevs.valueAt(i)->hwDevice();
Dima Zavin799a70e2011-04-18 16:57:27 -0700415 dev->dump(dev, fd);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700416 }
417 if (locked) mLock.unlock();
418 }
419 return NO_ERROR;
420}
421
Glenn Kasten98ec94c2012-01-25 14:28:29 -0800422sp<AudioFlinger::Client> AudioFlinger::registerPid_l(pid_t pid)
423{
424 // If pid is already in the mClients wp<> map, then use that entry
425 // (for which promote() is always != 0), otherwise create a new entry and Client.
426 sp<Client> client = mClients.valueFor(pid).promote();
427 if (client == 0) {
428 client = new Client(this, pid);
429 mClients.add(pid, client);
430 }
431
432 return client;
433}
Mathias Agopian65ab4712010-07-14 17:59:35 -0700434
435// IAudioFlinger interface
436
437
438sp<IAudioTrack> AudioFlinger::createTrack(
439 pid_t pid,
Glenn Kastenfff6d712012-01-12 16:38:12 -0800440 audio_stream_type_t streamType,
Mathias Agopian65ab4712010-07-14 17:59:35 -0700441 uint32_t sampleRate,
Glenn Kasten58f30212012-01-12 12:27:51 -0800442 audio_format_t format,
Jean-Michel Trivi0d255b22011-05-24 15:53:33 -0700443 uint32_t channelMask,
Mathias Agopian65ab4712010-07-14 17:59:35 -0700444 int frameCount,
Glenn Kastena075db42012-03-06 11:22:44 -0800445 IAudioFlinger::track_flags_t flags,
Mathias Agopian65ab4712010-07-14 17:59:35 -0700446 const sp<IMemory>& sharedBuffer,
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800447 audio_io_handle_t output,
Glenn Kasten3acbd052012-02-28 10:39:56 -0800448 pid_t tid,
Mathias Agopian65ab4712010-07-14 17:59:35 -0700449 int *sessionId,
450 status_t *status)
451{
452 sp<PlaybackThread::Track> track;
453 sp<TrackHandle> trackHandle;
454 sp<Client> client;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700455 status_t lStatus;
456 int lSessionId;
457
Glenn Kasten263709e2012-01-06 08:40:01 -0800458 // client AudioTrack::set already implements AUDIO_STREAM_DEFAULT => AUDIO_STREAM_MUSIC,
459 // but if someone uses binder directly they could bypass that and cause us to crash
460 if (uint32_t(streamType) >= AUDIO_STREAM_CNT) {
Steve Block29357bc2012-01-06 19:20:56 +0000461 ALOGE("createTrack() invalid stream type %d", streamType);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700462 lStatus = BAD_VALUE;
463 goto Exit;
464 }
465
466 {
467 Mutex::Autolock _l(mLock);
468 PlaybackThread *thread = checkPlaybackThread_l(output);
Eric Laurent39e94f82010-07-28 01:32:47 -0700469 PlaybackThread *effectThread = NULL;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700470 if (thread == NULL) {
Steve Block29357bc2012-01-06 19:20:56 +0000471 ALOGE("unknown output thread");
Mathias Agopian65ab4712010-07-14 17:59:35 -0700472 lStatus = BAD_VALUE;
473 goto Exit;
474 }
475
Glenn Kasten98ec94c2012-01-25 14:28:29 -0800476 client = registerPid_l(pid);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700477
Steve Block3856b092011-10-20 11:56:00 +0100478 ALOGV("createTrack() sessionId: %d", (sessionId == NULL) ? -2 : *sessionId);
Dima Zavinfce7a472011-04-19 22:30:36 -0700479 if (sessionId != NULL && *sessionId != AUDIO_SESSION_OUTPUT_MIX) {
Eric Laurentf436fdc2012-05-24 11:07:14 -0700480 // check if an effect chain with the same session ID is present on another
481 // output thread and move it here.
Eric Laurentde070132010-07-13 04:45:46 -0700482 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
Eric Laurent39e94f82010-07-28 01:32:47 -0700483 sp<PlaybackThread> t = mPlaybackThreads.valueAt(i);
484 if (mPlaybackThreads.keyAt(i) != output) {
Eric Laurent39e94f82010-07-28 01:32:47 -0700485 uint32_t sessions = t->hasAudioSession(*sessionId);
Eric Laurent39e94f82010-07-28 01:32:47 -0700486 if (sessions & PlaybackThread::EFFECT_SESSION) {
487 effectThread = t.get();
Eric Laurentf436fdc2012-05-24 11:07:14 -0700488 break;
Eric Laurent39e94f82010-07-28 01:32:47 -0700489 }
Eric Laurentde070132010-07-13 04:45:46 -0700490 }
491 }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700492 lSessionId = *sessionId;
493 } else {
Eric Laurentde070132010-07-13 04:45:46 -0700494 // if no audio session id is provided, create one here
Eric Laurent7c7f10b2011-06-17 21:29:58 -0700495 lSessionId = nextUniqueId();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700496 if (sessionId != NULL) {
497 *sessionId = lSessionId;
498 }
499 }
Steve Block3856b092011-10-20 11:56:00 +0100500 ALOGV("createTrack() lSessionId: %d", lSessionId);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700501
502 track = thread->createTrack_l(client, streamType, sampleRate, format,
Glenn Kasten3acbd052012-02-28 10:39:56 -0800503 channelMask, frameCount, sharedBuffer, lSessionId, flags, tid, &lStatus);
Eric Laurent39e94f82010-07-28 01:32:47 -0700504
505 // move effect chain to this output thread if an effect on same session was waiting
506 // for a track to be created
507 if (lStatus == NO_ERROR && effectThread != NULL) {
508 Mutex::Autolock _dl(thread->mLock);
509 Mutex::Autolock _sl(effectThread->mLock);
510 moveEffectChain_l(lSessionId, effectThread, thread, true);
511 }
Eric Laurenta011e352012-03-29 15:51:43 -0700512
513 // Look for sync events awaiting for a session to be used.
514 for (int i = 0; i < (int)mPendingSyncEvents.size(); i++) {
515 if (mPendingSyncEvents[i]->triggerSession() == lSessionId) {
516 if (thread->isValidSyncEvent(mPendingSyncEvents[i])) {
Eric Laurent29864602012-05-08 18:57:51 -0700517 if (lStatus == NO_ERROR) {
518 track->setSyncEvent(mPendingSyncEvents[i]);
519 } else {
520 mPendingSyncEvents[i]->cancel();
521 }
Eric Laurenta011e352012-03-29 15:51:43 -0700522 mPendingSyncEvents.removeAt(i);
523 i--;
524 }
525 }
526 }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700527 }
528 if (lStatus == NO_ERROR) {
529 trackHandle = new TrackHandle(track);
530 } else {
531 // remove local strong reference to Client before deleting the Track so that the Client
532 // destructor is called by the TrackBase destructor with mLock held
533 client.clear();
534 track.clear();
535 }
536
537Exit:
Glenn Kastene53b9ea2012-03-12 16:29:55 -0700538 if (status != NULL) {
Mathias Agopian65ab4712010-07-14 17:59:35 -0700539 *status = lStatus;
540 }
541 return trackHandle;
542}
543
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800544uint32_t AudioFlinger::sampleRate(audio_io_handle_t output) const
Mathias Agopian65ab4712010-07-14 17:59:35 -0700545{
546 Mutex::Autolock _l(mLock);
547 PlaybackThread *thread = checkPlaybackThread_l(output);
548 if (thread == NULL) {
Steve Block5ff1dd52012-01-05 23:22:43 +0000549 ALOGW("sampleRate() unknown thread %d", output);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700550 return 0;
551 }
552 return thread->sampleRate();
553}
554
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800555int AudioFlinger::channelCount(audio_io_handle_t output) const
Mathias Agopian65ab4712010-07-14 17:59:35 -0700556{
557 Mutex::Autolock _l(mLock);
558 PlaybackThread *thread = checkPlaybackThread_l(output);
559 if (thread == NULL) {
Steve Block5ff1dd52012-01-05 23:22:43 +0000560 ALOGW("channelCount() unknown thread %d", output);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700561 return 0;
562 }
563 return thread->channelCount();
564}
565
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800566audio_format_t AudioFlinger::format(audio_io_handle_t output) const
Mathias Agopian65ab4712010-07-14 17:59:35 -0700567{
568 Mutex::Autolock _l(mLock);
569 PlaybackThread *thread = checkPlaybackThread_l(output);
570 if (thread == NULL) {
Steve Block5ff1dd52012-01-05 23:22:43 +0000571 ALOGW("format() unknown thread %d", output);
Glenn Kasten58f30212012-01-12 12:27:51 -0800572 return AUDIO_FORMAT_INVALID;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700573 }
574 return thread->format();
575}
576
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800577size_t AudioFlinger::frameCount(audio_io_handle_t output) const
Mathias Agopian65ab4712010-07-14 17:59:35 -0700578{
579 Mutex::Autolock _l(mLock);
580 PlaybackThread *thread = checkPlaybackThread_l(output);
581 if (thread == NULL) {
Steve Block5ff1dd52012-01-05 23:22:43 +0000582 ALOGW("frameCount() unknown thread %d", output);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700583 return 0;
584 }
Glenn Kasten58912562012-04-03 10:45:00 -0700585 // FIXME currently returns the normal mixer's frame count to avoid confusing legacy callers;
586 // should examine all callers and fix them to handle smaller counts
Mathias Agopian65ab4712010-07-14 17:59:35 -0700587 return thread->frameCount();
588}
589
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800590uint32_t AudioFlinger::latency(audio_io_handle_t output) const
Mathias Agopian65ab4712010-07-14 17:59:35 -0700591{
592 Mutex::Autolock _l(mLock);
593 PlaybackThread *thread = checkPlaybackThread_l(output);
594 if (thread == NULL) {
Steve Block5ff1dd52012-01-05 23:22:43 +0000595 ALOGW("latency() unknown thread %d", output);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700596 return 0;
597 }
598 return thread->latency();
599}
600
601status_t AudioFlinger::setMasterVolume(float value)
602{
Eric Laurenta1884f92011-08-23 08:25:03 -0700603 status_t ret = initCheck();
604 if (ret != NO_ERROR) {
605 return ret;
606 }
607
Mathias Agopian65ab4712010-07-14 17:59:35 -0700608 // check calling permissions
609 if (!settingsAllowed()) {
610 return PERMISSION_DENIED;
611 }
612
John Grossman4ff14ba2012-02-08 16:37:41 -0800613 float swmv = value;
614
Eric Laurenta4c5a552012-03-29 10:12:40 -0700615 Mutex::Autolock _l(mLock);
616
Mathias Agopian65ab4712010-07-14 17:59:35 -0700617 // when hw supports master volume, don't scale in sw mixer
John Grossman4ff14ba2012-02-08 16:37:41 -0800618 if (MVS_NONE != mMasterVolumeSupportLvl) {
619 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
620 AutoMutex lock(mHardwareLock);
Eric Laurenta4c5a552012-03-29 10:12:40 -0700621 audio_hw_device_t *dev = mAudioHwDevs.valueAt(i)->hwDevice();
John Grossman4ff14ba2012-02-08 16:37:41 -0800622
623 mHardwareStatus = AUDIO_HW_SET_MASTER_VOLUME;
624 if (NULL != dev->set_master_volume) {
625 dev->set_master_volume(dev, value);
626 }
627 mHardwareStatus = AUDIO_HW_IDLE;
Eric Laurent93575202011-01-18 18:39:02 -0800628 }
John Grossman4ff14ba2012-02-08 16:37:41 -0800629
630 swmv = 1.0;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700631 }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700632
John Grossman4ff14ba2012-02-08 16:37:41 -0800633 mMasterVolume = value;
634 mMasterVolumeSW = swmv;
Glenn Kasten8d6a2442012-02-08 14:04:28 -0800635 for (size_t i = 0; i < mPlaybackThreads.size(); i++)
Glenn Kastene53b9ea2012-03-12 16:29:55 -0700636 mPlaybackThreads.valueAt(i)->setMasterVolume(swmv);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700637
638 return NO_ERROR;
639}
640
Glenn Kastenf78aee72012-01-04 11:00:47 -0800641status_t AudioFlinger::setMode(audio_mode_t mode)
Mathias Agopian65ab4712010-07-14 17:59:35 -0700642{
Eric Laurenta1884f92011-08-23 08:25:03 -0700643 status_t ret = initCheck();
644 if (ret != NO_ERROR) {
645 return ret;
646 }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700647
648 // check calling permissions
649 if (!settingsAllowed()) {
650 return PERMISSION_DENIED;
651 }
Glenn Kasten930f4ca2012-01-06 16:47:31 -0800652 if (uint32_t(mode) >= AUDIO_MODE_CNT) {
Steve Block5ff1dd52012-01-05 23:22:43 +0000653 ALOGW("Illegal value: setMode(%d)", mode);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700654 return BAD_VALUE;
655 }
656
657 { // scope for the lock
658 AutoMutex lock(mHardwareLock);
659 mHardwareStatus = AUDIO_HW_SET_MODE;
Dima Zavin799a70e2011-04-18 16:57:27 -0700660 ret = mPrimaryHardwareDev->set_mode(mPrimaryHardwareDev, mode);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700661 mHardwareStatus = AUDIO_HW_IDLE;
662 }
663
664 if (NO_ERROR == ret) {
665 Mutex::Autolock _l(mLock);
666 mMode = mode;
Glenn Kasten8d6a2442012-02-08 14:04:28 -0800667 for (size_t i = 0; i < mPlaybackThreads.size(); i++)
Glenn Kastene53b9ea2012-03-12 16:29:55 -0700668 mPlaybackThreads.valueAt(i)->setMode(mode);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700669 }
670
671 return ret;
672}
673
674status_t AudioFlinger::setMicMute(bool state)
675{
Eric Laurenta1884f92011-08-23 08:25:03 -0700676 status_t ret = initCheck();
677 if (ret != NO_ERROR) {
678 return ret;
679 }
680
Mathias Agopian65ab4712010-07-14 17:59:35 -0700681 // check calling permissions
682 if (!settingsAllowed()) {
683 return PERMISSION_DENIED;
684 }
685
686 AutoMutex lock(mHardwareLock);
687 mHardwareStatus = AUDIO_HW_SET_MIC_MUTE;
Eric Laurenta1884f92011-08-23 08:25:03 -0700688 ret = mPrimaryHardwareDev->set_mic_mute(mPrimaryHardwareDev, state);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700689 mHardwareStatus = AUDIO_HW_IDLE;
690 return ret;
691}
692
693bool AudioFlinger::getMicMute() const
694{
Eric Laurenta1884f92011-08-23 08:25:03 -0700695 status_t ret = initCheck();
696 if (ret != NO_ERROR) {
697 return false;
698 }
699
Dima Zavinfce7a472011-04-19 22:30:36 -0700700 bool state = AUDIO_MODE_INVALID;
Glenn Kasten2b213bc2012-02-02 14:05:20 -0800701 AutoMutex lock(mHardwareLock);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700702 mHardwareStatus = AUDIO_HW_GET_MIC_MUTE;
Dima Zavin799a70e2011-04-18 16:57:27 -0700703 mPrimaryHardwareDev->get_mic_mute(mPrimaryHardwareDev, &state);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700704 mHardwareStatus = AUDIO_HW_IDLE;
705 return state;
706}
707
708status_t AudioFlinger::setMasterMute(bool muted)
709{
710 // check calling permissions
711 if (!settingsAllowed()) {
712 return PERMISSION_DENIED;
713 }
714
Eric Laurent93575202011-01-18 18:39:02 -0800715 Mutex::Autolock _l(mLock);
Glenn Kasten99e53b82012-01-19 08:59:58 -0800716 // This is an optimization, so PlaybackThread doesn't have to look at the one from AudioFlinger
Mathias Agopian65ab4712010-07-14 17:59:35 -0700717 mMasterMute = muted;
Glenn Kasten8d6a2442012-02-08 14:04:28 -0800718 for (size_t i = 0; i < mPlaybackThreads.size(); i++)
Glenn Kastene53b9ea2012-03-12 16:29:55 -0700719 mPlaybackThreads.valueAt(i)->setMasterMute(muted);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700720
721 return NO_ERROR;
722}
723
724float AudioFlinger::masterVolume() const
725{
Glenn Kasten98067102011-12-13 11:47:54 -0800726 Mutex::Autolock _l(mLock);
727 return masterVolume_l();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700728}
729
John Grossman4ff14ba2012-02-08 16:37:41 -0800730float AudioFlinger::masterVolumeSW() const
731{
732 Mutex::Autolock _l(mLock);
733 return masterVolumeSW_l();
734}
735
Mathias Agopian65ab4712010-07-14 17:59:35 -0700736bool AudioFlinger::masterMute() const
737{
Glenn Kasten98067102011-12-13 11:47:54 -0800738 Mutex::Autolock _l(mLock);
739 return masterMute_l();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700740}
741
John Grossman4ff14ba2012-02-08 16:37:41 -0800742float AudioFlinger::masterVolume_l() const
743{
744 if (MVS_FULL == mMasterVolumeSupportLvl) {
745 float ret_val;
746 AutoMutex lock(mHardwareLock);
747
748 mHardwareStatus = AUDIO_HW_GET_MASTER_VOLUME;
Glenn Kasten5798d4e2012-03-08 12:18:35 -0800749 ALOG_ASSERT((NULL != mPrimaryHardwareDev) &&
750 (NULL != mPrimaryHardwareDev->get_master_volume),
751 "can't get master volume");
John Grossman4ff14ba2012-02-08 16:37:41 -0800752
753 mPrimaryHardwareDev->get_master_volume(mPrimaryHardwareDev, &ret_val);
754 mHardwareStatus = AUDIO_HW_IDLE;
755 return ret_val;
756 }
757
758 return mMasterVolume;
759}
760
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800761status_t AudioFlinger::setStreamVolume(audio_stream_type_t stream, float value,
762 audio_io_handle_t output)
Mathias Agopian65ab4712010-07-14 17:59:35 -0700763{
764 // check calling permissions
765 if (!settingsAllowed()) {
766 return PERMISSION_DENIED;
767 }
768
Glenn Kasten263709e2012-01-06 08:40:01 -0800769 if (uint32_t(stream) >= AUDIO_STREAM_CNT) {
Steve Block29357bc2012-01-06 19:20:56 +0000770 ALOGE("setStreamVolume() invalid stream %d", stream);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700771 return BAD_VALUE;
772 }
773
774 AutoMutex lock(mLock);
775 PlaybackThread *thread = NULL;
776 if (output) {
777 thread = checkPlaybackThread_l(output);
778 if (thread == NULL) {
779 return BAD_VALUE;
780 }
781 }
782
783 mStreamTypes[stream].volume = value;
784
785 if (thread == NULL) {
Glenn Kasten8d6a2442012-02-08 14:04:28 -0800786 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
Glenn Kastene53b9ea2012-03-12 16:29:55 -0700787 mPlaybackThreads.valueAt(i)->setStreamVolume(stream, value);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700788 }
789 } else {
790 thread->setStreamVolume(stream, value);
791 }
792
793 return NO_ERROR;
794}
795
Glenn Kastenfff6d712012-01-12 16:38:12 -0800796status_t AudioFlinger::setStreamMute(audio_stream_type_t stream, bool muted)
Mathias Agopian65ab4712010-07-14 17:59:35 -0700797{
798 // check calling permissions
799 if (!settingsAllowed()) {
800 return PERMISSION_DENIED;
801 }
802
Glenn Kasten263709e2012-01-06 08:40:01 -0800803 if (uint32_t(stream) >= AUDIO_STREAM_CNT ||
Dima Zavinfce7a472011-04-19 22:30:36 -0700804 uint32_t(stream) == AUDIO_STREAM_ENFORCED_AUDIBLE) {
Steve Block29357bc2012-01-06 19:20:56 +0000805 ALOGE("setStreamMute() invalid stream %d", stream);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700806 return BAD_VALUE;
807 }
808
Eric Laurent93575202011-01-18 18:39:02 -0800809 AutoMutex lock(mLock);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700810 mStreamTypes[stream].mute = muted;
811 for (uint32_t i = 0; i < mPlaybackThreads.size(); i++)
Glenn Kastene53b9ea2012-03-12 16:29:55 -0700812 mPlaybackThreads.valueAt(i)->setStreamMute(stream, muted);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700813
814 return NO_ERROR;
815}
816
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800817float AudioFlinger::streamVolume(audio_stream_type_t stream, audio_io_handle_t output) const
Mathias Agopian65ab4712010-07-14 17:59:35 -0700818{
Glenn Kasten263709e2012-01-06 08:40:01 -0800819 if (uint32_t(stream) >= AUDIO_STREAM_CNT) {
Mathias Agopian65ab4712010-07-14 17:59:35 -0700820 return 0.0f;
821 }
822
823 AutoMutex lock(mLock);
824 float volume;
825 if (output) {
826 PlaybackThread *thread = checkPlaybackThread_l(output);
827 if (thread == NULL) {
828 return 0.0f;
829 }
830 volume = thread->streamVolume(stream);
831 } else {
Glenn Kasten6637baa2012-01-09 09:40:36 -0800832 volume = streamVolume_l(stream);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700833 }
834
835 return volume;
836}
837
Glenn Kastenfff6d712012-01-12 16:38:12 -0800838bool AudioFlinger::streamMute(audio_stream_type_t stream) const
Mathias Agopian65ab4712010-07-14 17:59:35 -0700839{
Glenn Kasten263709e2012-01-06 08:40:01 -0800840 if (uint32_t(stream) >= AUDIO_STREAM_CNT) {
Mathias Agopian65ab4712010-07-14 17:59:35 -0700841 return true;
842 }
843
Glenn Kasten6637baa2012-01-09 09:40:36 -0800844 AutoMutex lock(mLock);
845 return streamMute_l(stream);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700846}
847
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800848status_t AudioFlinger::setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs)
Mathias Agopian65ab4712010-07-14 17:59:35 -0700849{
Glenn Kasten23d82a92012-02-03 11:10:00 -0800850 ALOGV("setParameters(): io %d, keyvalue %s, tid %d, calling pid %d",
Mathias Agopian65ab4712010-07-14 17:59:35 -0700851 ioHandle, keyValuePairs.string(), gettid(), IPCThreadState::self()->getCallingPid());
852 // check calling permissions
853 if (!settingsAllowed()) {
854 return PERMISSION_DENIED;
855 }
856
Mathias Agopian65ab4712010-07-14 17:59:35 -0700857 // ioHandle == 0 means the parameters are global to the audio hardware interface
858 if (ioHandle == 0) {
Eric Laurenta4c5a552012-03-29 10:12:40 -0700859 Mutex::Autolock _l(mLock);
Dima Zavin799a70e2011-04-18 16:57:27 -0700860 status_t final_result = NO_ERROR;
Glenn Kasten8abf44d2012-02-02 14:16:03 -0800861 {
Eric Laurenta4c5a552012-03-29 10:12:40 -0700862 AutoMutex lock(mHardwareLock);
863 mHardwareStatus = AUDIO_HW_SET_PARAMETER;
864 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
865 audio_hw_device_t *dev = mAudioHwDevs.valueAt(i)->hwDevice();
866 status_t result = dev->set_parameters(dev, keyValuePairs.string());
867 final_result = result ?: final_result;
868 }
869 mHardwareStatus = AUDIO_HW_IDLE;
Glenn Kasten8abf44d2012-02-02 14:16:03 -0800870 }
Eric Laurent59bd0da2011-08-01 09:52:20 -0700871 // disable AEC and NS if the device is a BT SCO headset supporting those pre processings
872 AudioParameter param = AudioParameter(keyValuePairs);
873 String8 value;
874 if (param.get(String8(AUDIO_PARAMETER_KEY_BT_NREC), value) == NO_ERROR) {
Eric Laurentbee53372011-08-29 12:42:48 -0700875 bool btNrecIsOff = (value == AUDIO_PARAMETER_VALUE_OFF);
876 if (mBtNrecIsOff != btNrecIsOff) {
Eric Laurent59bd0da2011-08-01 09:52:20 -0700877 for (size_t i = 0; i < mRecordThreads.size(); i++) {
878 sp<RecordThread> thread = mRecordThreads.valueAt(i);
879 RecordThread::RecordTrack *track = thread->track();
880 if (track != NULL) {
881 audio_devices_t device = (audio_devices_t)(
882 thread->device() & AUDIO_DEVICE_IN_ALL);
Eric Laurentbee53372011-08-29 12:42:48 -0700883 bool suspend = audio_is_bluetooth_sco_device(device) && btNrecIsOff;
Eric Laurent59bd0da2011-08-01 09:52:20 -0700884 thread->setEffectSuspended(FX_IID_AEC,
885 suspend,
886 track->sessionId());
887 thread->setEffectSuspended(FX_IID_NS,
888 suspend,
889 track->sessionId());
890 }
891 }
Eric Laurentbee53372011-08-29 12:42:48 -0700892 mBtNrecIsOff = btNrecIsOff;
Eric Laurent59bd0da2011-08-01 09:52:20 -0700893 }
894 }
Glenn Kasten28ed2f92012-06-07 10:17:54 -0700895 String8 screenState;
896 if (param.get(String8(AudioParameter::keyScreenState), screenState) == NO_ERROR) {
897 bool isOff = screenState == "off";
898 if (isOff != (gScreenState & 1)) {
899 gScreenState = ((gScreenState & ~1) + 2) | isOff;
900 }
901 }
Dima Zavin799a70e2011-04-18 16:57:27 -0700902 return final_result;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700903 }
904
905 // hold a strong ref on thread in case closeOutput() or closeInput() is called
906 // and the thread is exited once the lock is released
907 sp<ThreadBase> thread;
908 {
909 Mutex::Autolock _l(mLock);
910 thread = checkPlaybackThread_l(ioHandle);
911 if (thread == NULL) {
912 thread = checkRecordThread_l(ioHandle);
Glenn Kasten7fc9a6f2012-01-10 10:46:34 -0800913 } else if (thread == primaryPlaybackThread_l()) {
Eric Laurent7c7f10b2011-06-17 21:29:58 -0700914 // indicate output device change to all input threads for pre processing
915 AudioParameter param = AudioParameter(keyValuePairs);
916 int value;
Eric Laurent89d94e72012-03-16 20:37:59 -0700917 if ((param.getInt(String8(AudioParameter::keyRouting), value) == NO_ERROR) &&
918 (value != 0)) {
Eric Laurent7c7f10b2011-06-17 21:29:58 -0700919 for (size_t i = 0; i < mRecordThreads.size(); i++) {
920 mRecordThreads.valueAt(i)->setParameters(keyValuePairs);
921 }
922 }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700923 }
924 }
Glenn Kasten7378ca52012-01-20 13:44:40 -0800925 if (thread != 0) {
926 return thread->setParameters(keyValuePairs);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700927 }
928 return BAD_VALUE;
929}
930
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800931String8 AudioFlinger::getParameters(audio_io_handle_t ioHandle, const String8& keys) const
Mathias Agopian65ab4712010-07-14 17:59:35 -0700932{
Glenn Kasten23d82a92012-02-03 11:10:00 -0800933// ALOGV("getParameters() io %d, keys %s, tid %d, calling pid %d",
Mathias Agopian65ab4712010-07-14 17:59:35 -0700934// ioHandle, keys.string(), gettid(), IPCThreadState::self()->getCallingPid());
935
Eric Laurenta4c5a552012-03-29 10:12:40 -0700936 Mutex::Autolock _l(mLock);
937
Mathias Agopian65ab4712010-07-14 17:59:35 -0700938 if (ioHandle == 0) {
Dima Zavinfce7a472011-04-19 22:30:36 -0700939 String8 out_s8;
940
Dima Zavin799a70e2011-04-18 16:57:27 -0700941 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
Glenn Kasten8abf44d2012-02-02 14:16:03 -0800942 char *s;
943 {
944 AutoMutex lock(mHardwareLock);
945 mHardwareStatus = AUDIO_HW_GET_PARAMETER;
Eric Laurenta4c5a552012-03-29 10:12:40 -0700946 audio_hw_device_t *dev = mAudioHwDevs.valueAt(i)->hwDevice();
Glenn Kasten8abf44d2012-02-02 14:16:03 -0800947 s = dev->get_parameters(dev, keys.string());
948 mHardwareStatus = AUDIO_HW_IDLE;
949 }
John Grossmanef7740b2012-02-09 11:28:36 -0800950 out_s8 += String8(s ? s : "");
Dima Zavin799a70e2011-04-18 16:57:27 -0700951 free(s);
952 }
Dima Zavinfce7a472011-04-19 22:30:36 -0700953 return out_s8;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700954 }
955
Mathias Agopian65ab4712010-07-14 17:59:35 -0700956 PlaybackThread *playbackThread = checkPlaybackThread_l(ioHandle);
957 if (playbackThread != NULL) {
958 return playbackThread->getParameters(keys);
959 }
960 RecordThread *recordThread = checkRecordThread_l(ioHandle);
961 if (recordThread != NULL) {
962 return recordThread->getParameters(keys);
963 }
964 return String8("");
965}
966
Glenn Kastenf587ba52012-01-26 16:25:10 -0800967size_t AudioFlinger::getInputBufferSize(uint32_t sampleRate, audio_format_t format, int channelCount) const
Mathias Agopian65ab4712010-07-14 17:59:35 -0700968{
Eric Laurenta1884f92011-08-23 08:25:03 -0700969 status_t ret = initCheck();
970 if (ret != NO_ERROR) {
971 return 0;
972 }
973
Glenn Kasten2b213bc2012-02-02 14:05:20 -0800974 AutoMutex lock(mHardwareLock);
975 mHardwareStatus = AUDIO_HW_GET_INPUT_BUFFER_SIZE;
Eric Laurentf7ffb8b2012-04-14 09:06:57 -0700976 struct audio_config config = {
977 sample_rate: sampleRate,
978 channel_mask: audio_channel_in_mask_from_count(channelCount),
979 format: format,
980 };
981 size_t size = mPrimaryHardwareDev->get_input_buffer_size(mPrimaryHardwareDev, &config);
Glenn Kasten2b213bc2012-02-02 14:05:20 -0800982 mHardwareStatus = AUDIO_HW_IDLE;
983 return size;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700984}
985
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800986unsigned int AudioFlinger::getInputFramesLost(audio_io_handle_t ioHandle) const
Mathias Agopian65ab4712010-07-14 17:59:35 -0700987{
988 if (ioHandle == 0) {
989 return 0;
990 }
991
992 Mutex::Autolock _l(mLock);
993
994 RecordThread *recordThread = checkRecordThread_l(ioHandle);
995 if (recordThread != NULL) {
996 return recordThread->getInputFramesLost();
997 }
998 return 0;
999}
1000
1001status_t AudioFlinger::setVoiceVolume(float value)
1002{
Eric Laurenta1884f92011-08-23 08:25:03 -07001003 status_t ret = initCheck();
1004 if (ret != NO_ERROR) {
1005 return ret;
1006 }
1007
Mathias Agopian65ab4712010-07-14 17:59:35 -07001008 // check calling permissions
1009 if (!settingsAllowed()) {
1010 return PERMISSION_DENIED;
1011 }
1012
1013 AutoMutex lock(mHardwareLock);
Glenn Kasten8abf44d2012-02-02 14:16:03 -08001014 mHardwareStatus = AUDIO_HW_SET_VOICE_VOLUME;
Eric Laurenta1884f92011-08-23 08:25:03 -07001015 ret = mPrimaryHardwareDev->set_voice_volume(mPrimaryHardwareDev, value);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001016 mHardwareStatus = AUDIO_HW_IDLE;
1017
1018 return ret;
1019}
1020
Glenn Kasten72ef00d2012-01-17 11:09:42 -08001021status_t AudioFlinger::getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames,
1022 audio_io_handle_t output) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07001023{
1024 status_t status;
1025
1026 Mutex::Autolock _l(mLock);
1027
1028 PlaybackThread *playbackThread = checkPlaybackThread_l(output);
1029 if (playbackThread != NULL) {
1030 return playbackThread->getRenderPosition(halFrames, dspFrames);
1031 }
1032
1033 return BAD_VALUE;
1034}
1035
1036void AudioFlinger::registerClient(const sp<IAudioFlingerClient>& client)
1037{
1038
1039 Mutex::Autolock _l(mLock);
1040
Glenn Kastenbb001922012-02-03 11:10:26 -08001041 pid_t pid = IPCThreadState::self()->getCallingPid();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001042 if (mNotificationClients.indexOfKey(pid) < 0) {
1043 sp<NotificationClient> notificationClient = new NotificationClient(this,
1044 client,
1045 pid);
Steve Block3856b092011-10-20 11:56:00 +01001046 ALOGV("registerClient() client %p, pid %d", notificationClient.get(), pid);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001047
1048 mNotificationClients.add(pid, notificationClient);
1049
1050 sp<IBinder> binder = client->asBinder();
1051 binder->linkToDeath(notificationClient);
1052
1053 // the config change is always sent from playback or record threads to avoid deadlock
1054 // with AudioSystem::gLock
1055 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
1056 mPlaybackThreads.valueAt(i)->sendConfigEvent(AudioSystem::OUTPUT_OPENED);
1057 }
1058
1059 for (size_t i = 0; i < mRecordThreads.size(); i++) {
1060 mRecordThreads.valueAt(i)->sendConfigEvent(AudioSystem::INPUT_OPENED);
1061 }
1062 }
1063}
1064
1065void AudioFlinger::removeNotificationClient(pid_t pid)
1066{
1067 Mutex::Autolock _l(mLock);
1068
Glenn Kastena3b09252012-01-20 09:19:01 -08001069 mNotificationClients.removeItem(pid);
Marco Nelissen3a34bef2011-08-02 13:33:41 -07001070
Steve Block3856b092011-10-20 11:56:00 +01001071 ALOGV("%d died, releasing its sessions", pid);
Glenn Kasten8d6a2442012-02-08 14:04:28 -08001072 size_t num = mAudioSessionRefs.size();
Marco Nelissen3a34bef2011-08-02 13:33:41 -07001073 bool removed = false;
Glenn Kasten8d6a2442012-02-08 14:04:28 -08001074 for (size_t i = 0; i< num; ) {
Marco Nelissen3a34bef2011-08-02 13:33:41 -07001075 AudioSessionRef *ref = mAudioSessionRefs.itemAt(i);
Glenn Kasten012ca6b2012-03-06 11:22:01 -08001076 ALOGV(" pid %d @ %d", ref->mPid, i);
1077 if (ref->mPid == pid) {
1078 ALOGV(" removing entry for pid %d session %d", pid, ref->mSessionid);
Marco Nelissen3a34bef2011-08-02 13:33:41 -07001079 mAudioSessionRefs.removeAt(i);
1080 delete ref;
1081 removed = true;
Marco Nelissen3a34bef2011-08-02 13:33:41 -07001082 num--;
Glenn Kasten8d6a2442012-02-08 14:04:28 -08001083 } else {
1084 i++;
Marco Nelissen3a34bef2011-08-02 13:33:41 -07001085 }
1086 }
1087 if (removed) {
1088 purgeStaleEffects_l();
1089 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001090}
1091
1092// audioConfigChanged_l() must be called with AudioFlinger::mLock held
Glenn Kastenb81cc8c2012-03-01 09:14:51 -08001093void AudioFlinger::audioConfigChanged_l(int event, audio_io_handle_t ioHandle, const void *param2)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001094{
1095 size_t size = mNotificationClients.size();
1096 for (size_t i = 0; i < size; i++) {
Glenn Kasten84afa3b2012-01-25 15:28:08 -08001097 mNotificationClients.valueAt(i)->audioFlingerClient()->ioConfigChanged(event, ioHandle,
1098 param2);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001099 }
1100}
1101
1102// removeClient_l() must be called with AudioFlinger::mLock held
1103void AudioFlinger::removeClient_l(pid_t pid)
1104{
Steve Block3856b092011-10-20 11:56:00 +01001105 ALOGV("removeClient_l() pid %d, tid %d, calling tid %d", pid, gettid(), IPCThreadState::self()->getCallingPid());
Mathias Agopian65ab4712010-07-14 17:59:35 -07001106 mClients.removeItem(pid);
1107}
1108
1109
1110// ----------------------------------------------------------------------------
1111
Glenn Kasten72ef00d2012-01-17 11:09:42 -08001112AudioFlinger::ThreadBase::ThreadBase(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
1113 uint32_t device, type_t type)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001114 : Thread(false),
Glenn Kasten23bb8be2012-01-26 10:38:26 -08001115 mType(type),
Glenn Kasten58912562012-04-03 10:45:00 -07001116 mAudioFlinger(audioFlinger), mSampleRate(0), mFrameCount(0), mNormalFrameCount(0),
Glenn Kasten84afa3b2012-01-25 15:28:08 -08001117 // mChannelMask
1118 mChannelCount(0),
1119 mFrameSize(1), mFormat(AUDIO_FORMAT_INVALID),
1120 mParamStatus(NO_ERROR),
Glenn Kastenb28686f2012-01-06 08:39:38 -08001121 mStandby(false), mId(id),
Glenn Kasten84afa3b2012-01-25 15:28:08 -08001122 mDevice(device),
1123 mDeathRecipient(new PMDeathRecipient(this))
Mathias Agopian65ab4712010-07-14 17:59:35 -07001124{
1125}
1126
1127AudioFlinger::ThreadBase::~ThreadBase()
1128{
1129 mParamCond.broadcast();
Eric Laurentfeb0db62011-07-22 09:04:31 -07001130 // do not lock the mutex in destructor
1131 releaseWakeLock_l();
Eric Laurent9d18ec52011-09-27 12:07:15 -07001132 if (mPowerManager != 0) {
1133 sp<IBinder> binder = mPowerManager->asBinder();
1134 binder->unlinkToDeath(mDeathRecipient);
1135 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001136}
1137
1138void AudioFlinger::ThreadBase::exit()
1139{
Steve Block3856b092011-10-20 11:56:00 +01001140 ALOGV("ThreadBase::exit");
Mathias Agopian65ab4712010-07-14 17:59:35 -07001141 {
Glenn Kastenb28686f2012-01-06 08:39:38 -08001142 // This lock prevents the following race in thread (uniprocessor for illustration):
1143 // if (!exitPending()) {
1144 // // context switch from here to exit()
1145 // // exit() calls requestExit(), what exitPending() observes
1146 // // exit() calls signal(), which is dropped since no waiters
1147 // // context switch back from exit() to here
1148 // mWaitWorkCV.wait(...);
1149 // // now thread is hung
1150 // }
Glenn Kastena7d8d6f2012-01-05 15:41:56 -08001151 AutoMutex lock(mLock);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001152 requestExit();
1153 mWaitWorkCV.signal();
1154 }
Glenn Kastenb28686f2012-01-06 08:39:38 -08001155 // When Thread::requestExitAndWait is made virtual and this method is renamed to
1156 // "virtual status_t requestExitAndWait()", replace by "return Thread::requestExitAndWait();"
Mathias Agopian65ab4712010-07-14 17:59:35 -07001157 requestExitAndWait();
1158}
1159
Mathias Agopian65ab4712010-07-14 17:59:35 -07001160status_t AudioFlinger::ThreadBase::setParameters(const String8& keyValuePairs)
1161{
1162 status_t status;
1163
Steve Block3856b092011-10-20 11:56:00 +01001164 ALOGV("ThreadBase::setParameters() %s", keyValuePairs.string());
Mathias Agopian65ab4712010-07-14 17:59:35 -07001165 Mutex::Autolock _l(mLock);
1166
1167 mNewParameters.add(keyValuePairs);
1168 mWaitWorkCV.signal();
1169 // wait condition with timeout in case the thread loop has exited
1170 // before the request could be processed
Glenn Kasten7dede872011-12-13 11:04:14 -08001171 if (mParamCond.waitRelative(mLock, kSetParametersTimeoutNs) == NO_ERROR) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001172 status = mParamStatus;
1173 mWaitWorkCV.signal();
1174 } else {
1175 status = TIMED_OUT;
1176 }
1177 return status;
1178}
1179
1180void AudioFlinger::ThreadBase::sendConfigEvent(int event, int param)
1181{
1182 Mutex::Autolock _l(mLock);
1183 sendConfigEvent_l(event, param);
1184}
1185
1186// sendConfigEvent_l() must be called with ThreadBase::mLock held
1187void AudioFlinger::ThreadBase::sendConfigEvent_l(int event, int param)
1188{
Glenn Kastenf3990f22011-12-13 11:50:00 -08001189 ConfigEvent configEvent;
1190 configEvent.mEvent = event;
1191 configEvent.mParam = param;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001192 mConfigEvents.add(configEvent);
Steve Block3856b092011-10-20 11:56:00 +01001193 ALOGV("sendConfigEvent() num events %d event %d, param %d", mConfigEvents.size(), event, param);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001194 mWaitWorkCV.signal();
1195}
1196
1197void AudioFlinger::ThreadBase::processConfigEvents()
1198{
1199 mLock.lock();
Glenn Kastene53b9ea2012-03-12 16:29:55 -07001200 while (!mConfigEvents.isEmpty()) {
Steve Block3856b092011-10-20 11:56:00 +01001201 ALOGV("processConfigEvents() remaining events %d", mConfigEvents.size());
Glenn Kastenf3990f22011-12-13 11:50:00 -08001202 ConfigEvent configEvent = mConfigEvents[0];
Mathias Agopian65ab4712010-07-14 17:59:35 -07001203 mConfigEvents.removeAt(0);
1204 // release mLock before locking AudioFlinger mLock: lock order is always
1205 // AudioFlinger then ThreadBase to avoid cross deadlock
1206 mLock.unlock();
1207 mAudioFlinger->mLock.lock();
Glenn Kastenf3990f22011-12-13 11:50:00 -08001208 audioConfigChanged_l(configEvent.mEvent, configEvent.mParam);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001209 mAudioFlinger->mLock.unlock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001210 mLock.lock();
1211 }
1212 mLock.unlock();
1213}
1214
1215status_t AudioFlinger::ThreadBase::dumpBase(int fd, const Vector<String16>& args)
1216{
1217 const size_t SIZE = 256;
1218 char buffer[SIZE];
1219 String8 result;
1220
1221 bool locked = tryLock(mLock);
1222 if (!locked) {
1223 snprintf(buffer, SIZE, "thread %p maybe dead locked\n", this);
1224 write(fd, buffer, strlen(buffer));
1225 }
1226
Eric Laurent612bbb52012-03-14 15:03:26 -07001227 snprintf(buffer, SIZE, "io handle: %d\n", mId);
1228 result.append(buffer);
1229 snprintf(buffer, SIZE, "TID: %d\n", getTid());
1230 result.append(buffer);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001231 snprintf(buffer, SIZE, "standby: %d\n", mStandby);
1232 result.append(buffer);
1233 snprintf(buffer, SIZE, "Sample rate: %d\n", mSampleRate);
1234 result.append(buffer);
Glenn Kasten58912562012-04-03 10:45:00 -07001235 snprintf(buffer, SIZE, "HAL frame count: %d\n", mFrameCount);
1236 result.append(buffer);
1237 snprintf(buffer, SIZE, "Normal frame count: %d\n", mNormalFrameCount);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001238 result.append(buffer);
1239 snprintf(buffer, SIZE, "Channel Count: %d\n", mChannelCount);
1240 result.append(buffer);
Jean-Michel Trivi0d255b22011-05-24 15:53:33 -07001241 snprintf(buffer, SIZE, "Channel Mask: 0x%08x\n", mChannelMask);
1242 result.append(buffer);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001243 snprintf(buffer, SIZE, "Format: %d\n", mFormat);
1244 result.append(buffer);
Glenn Kastenb9980652012-01-11 09:48:27 -08001245 snprintf(buffer, SIZE, "Frame size: %u\n", mFrameSize);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001246 result.append(buffer);
1247
1248 snprintf(buffer, SIZE, "\nPending setParameters commands: \n");
1249 result.append(buffer);
1250 result.append(" Index Command");
1251 for (size_t i = 0; i < mNewParameters.size(); ++i) {
1252 snprintf(buffer, SIZE, "\n %02d ", i);
1253 result.append(buffer);
1254 result.append(mNewParameters[i]);
1255 }
1256
1257 snprintf(buffer, SIZE, "\n\nPending config events: \n");
1258 result.append(buffer);
1259 snprintf(buffer, SIZE, " Index event param\n");
1260 result.append(buffer);
1261 for (size_t i = 0; i < mConfigEvents.size(); i++) {
Glenn Kastenf3990f22011-12-13 11:50:00 -08001262 snprintf(buffer, SIZE, " %02d %02d %d\n", i, mConfigEvents[i].mEvent, mConfigEvents[i].mParam);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001263 result.append(buffer);
1264 }
1265 result.append("\n");
1266
1267 write(fd, result.string(), result.size());
1268
1269 if (locked) {
1270 mLock.unlock();
1271 }
1272 return NO_ERROR;
1273}
1274
Eric Laurent1d2bff02011-07-24 17:49:51 -07001275status_t AudioFlinger::ThreadBase::dumpEffectChains(int fd, const Vector<String16>& args)
1276{
1277 const size_t SIZE = 256;
1278 char buffer[SIZE];
1279 String8 result;
1280
1281 snprintf(buffer, SIZE, "\n- %d Effect Chains:\n", mEffectChains.size());
1282 write(fd, buffer, strlen(buffer));
1283
1284 for (size_t i = 0; i < mEffectChains.size(); ++i) {
1285 sp<EffectChain> chain = mEffectChains[i];
1286 if (chain != 0) {
1287 chain->dump(fd, args);
1288 }
1289 }
1290 return NO_ERROR;
1291}
1292
Eric Laurentfeb0db62011-07-22 09:04:31 -07001293void AudioFlinger::ThreadBase::acquireWakeLock()
1294{
1295 Mutex::Autolock _l(mLock);
1296 acquireWakeLock_l();
1297}
1298
1299void AudioFlinger::ThreadBase::acquireWakeLock_l()
1300{
1301 if (mPowerManager == 0) {
1302 // use checkService() to avoid blocking if power service is not up yet
1303 sp<IBinder> binder =
1304 defaultServiceManager()->checkService(String16("power"));
1305 if (binder == 0) {
Steve Block5ff1dd52012-01-05 23:22:43 +00001306 ALOGW("Thread %s cannot connect to the power manager service", mName);
Eric Laurentfeb0db62011-07-22 09:04:31 -07001307 } else {
1308 mPowerManager = interface_cast<IPowerManager>(binder);
1309 binder->linkToDeath(mDeathRecipient);
1310 }
1311 }
1312 if (mPowerManager != 0) {
1313 sp<IBinder> binder = new BBinder();
1314 status_t status = mPowerManager->acquireWakeLock(POWERMANAGER_PARTIAL_WAKE_LOCK,
1315 binder,
1316 String16(mName));
1317 if (status == NO_ERROR) {
1318 mWakeLockToken = binder;
1319 }
Steve Block3856b092011-10-20 11:56:00 +01001320 ALOGV("acquireWakeLock_l() %s status %d", mName, status);
Eric Laurentfeb0db62011-07-22 09:04:31 -07001321 }
1322}
1323
1324void AudioFlinger::ThreadBase::releaseWakeLock()
1325{
1326 Mutex::Autolock _l(mLock);
Eric Laurent6dbe8832011-07-28 13:59:02 -07001327 releaseWakeLock_l();
Eric Laurentfeb0db62011-07-22 09:04:31 -07001328}
1329
1330void AudioFlinger::ThreadBase::releaseWakeLock_l()
1331{
1332 if (mWakeLockToken != 0) {
Steve Block3856b092011-10-20 11:56:00 +01001333 ALOGV("releaseWakeLock_l() %s", mName);
Eric Laurentfeb0db62011-07-22 09:04:31 -07001334 if (mPowerManager != 0) {
1335 mPowerManager->releaseWakeLock(mWakeLockToken, 0);
1336 }
1337 mWakeLockToken.clear();
1338 }
1339}
1340
1341void AudioFlinger::ThreadBase::clearPowerManager()
1342{
1343 Mutex::Autolock _l(mLock);
1344 releaseWakeLock_l();
1345 mPowerManager.clear();
1346}
1347
1348void AudioFlinger::ThreadBase::PMDeathRecipient::binderDied(const wp<IBinder>& who)
1349{
1350 sp<ThreadBase> thread = mThread.promote();
1351 if (thread != 0) {
1352 thread->clearPowerManager();
1353 }
Steve Block5ff1dd52012-01-05 23:22:43 +00001354 ALOGW("power manager service died !!!");
Eric Laurentfeb0db62011-07-22 09:04:31 -07001355}
Eric Laurent1d2bff02011-07-24 17:49:51 -07001356
Eric Laurent59255e42011-07-27 19:49:51 -07001357void AudioFlinger::ThreadBase::setEffectSuspended(
1358 const effect_uuid_t *type, bool suspend, int sessionId)
1359{
1360 Mutex::Autolock _l(mLock);
1361 setEffectSuspended_l(type, suspend, sessionId);
1362}
1363
1364void AudioFlinger::ThreadBase::setEffectSuspended_l(
1365 const effect_uuid_t *type, bool suspend, int sessionId)
1366{
Glenn Kasten090f0192012-01-30 13:00:02 -08001367 sp<EffectChain> chain = getEffectChain_l(sessionId);
Eric Laurent59255e42011-07-27 19:49:51 -07001368 if (chain != 0) {
1369 if (type != NULL) {
1370 chain->setEffectSuspended_l(type, suspend);
1371 } else {
1372 chain->setEffectSuspendedAll_l(suspend);
1373 }
1374 }
1375
1376 updateSuspendedSessions_l(type, suspend, sessionId);
1377}
1378
1379void AudioFlinger::ThreadBase::checkSuspendOnAddEffectChain_l(const sp<EffectChain>& chain)
1380{
Glenn Kasten8d6a2442012-02-08 14:04:28 -08001381 ssize_t index = mSuspendedSessions.indexOfKey(chain->sessionId());
Eric Laurent59255e42011-07-27 19:49:51 -07001382 if (index < 0) {
1383 return;
1384 }
1385
1386 KeyedVector <int, sp<SuspendedSessionDesc> > sessionEffects =
1387 mSuspendedSessions.editValueAt(index);
1388
1389 for (size_t i = 0; i < sessionEffects.size(); i++) {
Glenn Kastene53b9ea2012-03-12 16:29:55 -07001390 sp<SuspendedSessionDesc> desc = sessionEffects.valueAt(i);
Eric Laurent59255e42011-07-27 19:49:51 -07001391 for (int j = 0; j < desc->mRefCount; j++) {
1392 if (sessionEffects.keyAt(i) == EffectChain::kKeyForSuspendAll) {
1393 chain->setEffectSuspendedAll_l(true);
1394 } else {
Steve Block3856b092011-10-20 11:56:00 +01001395 ALOGV("checkSuspendOnAddEffectChain_l() suspending effects %08x",
Glenn Kastene53b9ea2012-03-12 16:29:55 -07001396 desc->mType.timeLow);
Eric Laurent59255e42011-07-27 19:49:51 -07001397 chain->setEffectSuspended_l(&desc->mType, true);
1398 }
1399 }
1400 }
1401}
1402
Eric Laurent59255e42011-07-27 19:49:51 -07001403void AudioFlinger::ThreadBase::updateSuspendedSessions_l(const effect_uuid_t *type,
1404 bool suspend,
1405 int sessionId)
1406{
Glenn Kasten8d6a2442012-02-08 14:04:28 -08001407 ssize_t index = mSuspendedSessions.indexOfKey(sessionId);
Eric Laurent59255e42011-07-27 19:49:51 -07001408
1409 KeyedVector <int, sp<SuspendedSessionDesc> > sessionEffects;
1410
1411 if (suspend) {
1412 if (index >= 0) {
1413 sessionEffects = mSuspendedSessions.editValueAt(index);
1414 } else {
1415 mSuspendedSessions.add(sessionId, sessionEffects);
1416 }
1417 } else {
1418 if (index < 0) {
1419 return;
1420 }
1421 sessionEffects = mSuspendedSessions.editValueAt(index);
1422 }
1423
1424
1425 int key = EffectChain::kKeyForSuspendAll;
1426 if (type != NULL) {
1427 key = type->timeLow;
1428 }
1429 index = sessionEffects.indexOfKey(key);
1430
Glenn Kastene53b9ea2012-03-12 16:29:55 -07001431 sp<SuspendedSessionDesc> desc;
Eric Laurent59255e42011-07-27 19:49:51 -07001432 if (suspend) {
1433 if (index >= 0) {
1434 desc = sessionEffects.valueAt(index);
1435 } else {
1436 desc = new SuspendedSessionDesc();
1437 if (type != NULL) {
1438 memcpy(&desc->mType, type, sizeof(effect_uuid_t));
1439 }
1440 sessionEffects.add(key, desc);
Steve Block3856b092011-10-20 11:56:00 +01001441 ALOGV("updateSuspendedSessions_l() suspend adding effect %08x", key);
Eric Laurent59255e42011-07-27 19:49:51 -07001442 }
1443 desc->mRefCount++;
1444 } else {
1445 if (index < 0) {
1446 return;
1447 }
1448 desc = sessionEffects.valueAt(index);
1449 if (--desc->mRefCount == 0) {
Steve Block3856b092011-10-20 11:56:00 +01001450 ALOGV("updateSuspendedSessions_l() restore removing effect %08x", key);
Eric Laurent59255e42011-07-27 19:49:51 -07001451 sessionEffects.removeItemsAt(index);
1452 if (sessionEffects.isEmpty()) {
Steve Block3856b092011-10-20 11:56:00 +01001453 ALOGV("updateSuspendedSessions_l() restore removing session %d",
Eric Laurent59255e42011-07-27 19:49:51 -07001454 sessionId);
1455 mSuspendedSessions.removeItem(sessionId);
1456 }
1457 }
1458 }
1459 if (!sessionEffects.isEmpty()) {
1460 mSuspendedSessions.replaceValueFor(sessionId, sessionEffects);
1461 }
1462}
1463
1464void AudioFlinger::ThreadBase::checkSuspendOnEffectEnabled(const sp<EffectModule>& effect,
1465 bool enabled,
1466 int sessionId)
1467{
1468 Mutex::Autolock _l(mLock);
Eric Laurenta85a74a2011-10-19 11:44:54 -07001469 checkSuspendOnEffectEnabled_l(effect, enabled, sessionId);
1470}
Eric Laurent59255e42011-07-27 19:49:51 -07001471
Eric Laurenta85a74a2011-10-19 11:44:54 -07001472void AudioFlinger::ThreadBase::checkSuspendOnEffectEnabled_l(const sp<EffectModule>& effect,
1473 bool enabled,
1474 int sessionId)
1475{
Eric Laurentdb7c0792011-08-10 10:37:50 -07001476 if (mType != RECORD) {
1477 // suspend all effects in AUDIO_SESSION_OUTPUT_MIX when enabling any effect on
1478 // another session. This gives the priority to well behaved effect control panels
1479 // and applications not using global effects.
Eric Laurent808e7d12012-05-11 19:44:09 -07001480 // Enabling post processing in AUDIO_SESSION_OUTPUT_STAGE session does not affect
1481 // global effects
1482 if ((sessionId != AUDIO_SESSION_OUTPUT_MIX) && (sessionId != AUDIO_SESSION_OUTPUT_STAGE)) {
Eric Laurentdb7c0792011-08-10 10:37:50 -07001483 setEffectSuspended_l(NULL, enabled, AUDIO_SESSION_OUTPUT_MIX);
1484 }
1485 }
Eric Laurent59255e42011-07-27 19:49:51 -07001486
1487 sp<EffectChain> chain = getEffectChain_l(sessionId);
1488 if (chain != 0) {
1489 chain->checkSuspendOnEffectEnabled(effect, enabled);
1490 }
1491}
1492
Mathias Agopian65ab4712010-07-14 17:59:35 -07001493// ----------------------------------------------------------------------------
1494
Eric Laurent7c7f10b2011-06-17 21:29:58 -07001495AudioFlinger::PlaybackThread::PlaybackThread(const sp<AudioFlinger>& audioFlinger,
1496 AudioStreamOut* output,
Glenn Kasten72ef00d2012-01-17 11:09:42 -08001497 audio_io_handle_t id,
Glenn Kasten23bb8be2012-01-26 10:38:26 -08001498 uint32_t device,
1499 type_t type)
1500 : ThreadBase(audioFlinger, id, device, type),
Glenn Kasten84afa3b2012-01-25 15:28:08 -08001501 mMixBuffer(NULL), mSuspended(0), mBytesWritten(0),
1502 // Assumes constructor is called by AudioFlinger with it's mLock held,
1503 // but it would be safer to explicitly pass initial masterMute as parameter
1504 mMasterMute(audioFlinger->masterMute_l()),
1505 // mStreamTypes[] initialized in constructor body
1506 mOutput(output),
1507 // Assumes constructor is called by AudioFlinger with it's mLock held,
1508 // but it would be safer to explicitly pass initial masterVolume as parameter
John Grossman4ff14ba2012-02-08 16:37:41 -08001509 mMasterVolume(audioFlinger->masterVolumeSW_l()),
Glenn Kastenfec279f2012-03-08 07:47:15 -08001510 mLastWriteTime(0), mNumWrites(0), mNumDelayedWrites(0), mInWrite(false),
Glenn Kastenaa4397f2012-03-12 18:13:59 -07001511 mMixerStatus(MIXER_IDLE),
Glenn Kasten81028042012-04-30 18:15:12 -07001512 mMixerStatusIgnoringFastTracks(MIXER_IDLE),
Glenn Kasten58912562012-04-03 10:45:00 -07001513 standbyDelay(AudioFlinger::mStandbyTimeInNsecs),
Glenn Kasten28ed2f92012-06-07 10:17:54 -07001514 mScreenState(gScreenState),
Glenn Kasten288ed212012-04-25 17:52:27 -07001515 // index 0 is reserved for normal mixer's submix
1516 mFastTrackAvailMask(((1 << FastMixerState::kMaxFastTracks) - 1) & ~1)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001517{
Glenn Kasten480b4682012-02-28 12:30:08 -08001518 snprintf(mName, kNameLength, "AudioOut_%X", id);
Eric Laurentfeb0db62011-07-22 09:04:31 -07001519
Mathias Agopian65ab4712010-07-14 17:59:35 -07001520 readOutputParameters();
1521
Glenn Kasten263709e2012-01-06 08:40:01 -08001522 // mStreamTypes[AUDIO_STREAM_CNT] is initialized by stream_type_t default constructor
Glenn Kastenfff6d712012-01-12 16:38:12 -08001523 // There is no AUDIO_STREAM_MIN, and ++ operator does not compile
1524 for (audio_stream_type_t stream = (audio_stream_type_t) 0; stream < AUDIO_STREAM_CNT;
1525 stream = (audio_stream_type_t) (stream + 1)) {
Glenn Kasten6637baa2012-01-09 09:40:36 -08001526 mStreamTypes[stream].volume = mAudioFlinger->streamVolume_l(stream);
1527 mStreamTypes[stream].mute = mAudioFlinger->streamMute_l(stream);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001528 }
Glenn Kasten6637baa2012-01-09 09:40:36 -08001529 // mStreamTypes[AUDIO_STREAM_CNT] exists but isn't explicitly initialized here,
1530 // because mAudioFlinger doesn't have one to copy from
Mathias Agopian65ab4712010-07-14 17:59:35 -07001531}
1532
1533AudioFlinger::PlaybackThread::~PlaybackThread()
1534{
1535 delete [] mMixBuffer;
1536}
1537
1538status_t AudioFlinger::PlaybackThread::dump(int fd, const Vector<String16>& args)
1539{
1540 dumpInternals(fd, args);
1541 dumpTracks(fd, args);
1542 dumpEffectChains(fd, args);
1543 return NO_ERROR;
1544}
1545
1546status_t AudioFlinger::PlaybackThread::dumpTracks(int fd, const Vector<String16>& args)
1547{
1548 const size_t SIZE = 256;
1549 char buffer[SIZE];
1550 String8 result;
1551
Glenn Kasten58912562012-04-03 10:45:00 -07001552 result.appendFormat("Output thread %p stream volumes in dB:\n ", this);
1553 for (int i = 0; i < AUDIO_STREAM_CNT; ++i) {
1554 const stream_type_t *st = &mStreamTypes[i];
1555 if (i > 0) {
1556 result.appendFormat(", ");
1557 }
1558 result.appendFormat("%d:%.2g", i, 20.0 * log10(st->volume));
1559 if (st->mute) {
1560 result.append("M");
1561 }
1562 }
1563 result.append("\n");
1564 write(fd, result.string(), result.length());
1565 result.clear();
1566
Mathias Agopian65ab4712010-07-14 17:59:35 -07001567 snprintf(buffer, SIZE, "Output thread %p tracks\n", this);
1568 result.append(buffer);
Glenn Kasten288ed212012-04-25 17:52:27 -07001569 Track::appendDumpHeader(result);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001570 for (size_t i = 0; i < mTracks.size(); ++i) {
1571 sp<Track> track = mTracks[i];
1572 if (track != 0) {
1573 track->dump(buffer, SIZE);
1574 result.append(buffer);
1575 }
1576 }
1577
1578 snprintf(buffer, SIZE, "Output thread %p active tracks\n", this);
1579 result.append(buffer);
Glenn Kasten288ed212012-04-25 17:52:27 -07001580 Track::appendDumpHeader(result);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001581 for (size_t i = 0; i < mActiveTracks.size(); ++i) {
Glenn Kasten77c11192012-01-25 14:27:41 -08001582 sp<Track> track = mActiveTracks[i].promote();
1583 if (track != 0) {
1584 track->dump(buffer, SIZE);
1585 result.append(buffer);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001586 }
1587 }
1588 write(fd, result.string(), result.size());
Glenn Kasten88cbea82012-05-15 07:39:27 -07001589
1590 // These values are "raw"; they will wrap around. See prepareTracks_l() for a better way.
1591 FastTrackUnderruns underruns = getFastTrackUnderruns(0);
1592 fdprintf(fd, "Normal mixer raw underrun counters: partial=%u empty=%u\n",
1593 underruns.mBitFields.mPartial, underruns.mBitFields.mEmpty);
1594
Mathias Agopian65ab4712010-07-14 17:59:35 -07001595 return NO_ERROR;
1596}
1597
Mathias Agopian65ab4712010-07-14 17:59:35 -07001598status_t AudioFlinger::PlaybackThread::dumpInternals(int fd, const Vector<String16>& args)
1599{
1600 const size_t SIZE = 256;
1601 char buffer[SIZE];
1602 String8 result;
1603
1604 snprintf(buffer, SIZE, "\nOutput thread %p internals\n", this);
1605 result.append(buffer);
1606 snprintf(buffer, SIZE, "last write occurred (msecs): %llu\n", ns2ms(systemTime() - mLastWriteTime));
1607 result.append(buffer);
1608 snprintf(buffer, SIZE, "total writes: %d\n", mNumWrites);
1609 result.append(buffer);
1610 snprintf(buffer, SIZE, "delayed writes: %d\n", mNumDelayedWrites);
1611 result.append(buffer);
1612 snprintf(buffer, SIZE, "blocked in write: %d\n", mInWrite);
1613 result.append(buffer);
1614 snprintf(buffer, SIZE, "suspend count: %d\n", mSuspended);
1615 result.append(buffer);
1616 snprintf(buffer, SIZE, "mix buffer : %p\n", mMixBuffer);
1617 result.append(buffer);
1618 write(fd, result.string(), result.size());
Glenn Kasten1295bb4d2012-05-31 07:43:43 -07001619 fdprintf(fd, "Fast track availMask=%#x\n", mFastTrackAvailMask);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001620
1621 dumpBase(fd, args);
1622
1623 return NO_ERROR;
1624}
1625
1626// Thread virtuals
1627status_t AudioFlinger::PlaybackThread::readyToRun()
1628{
Eric Laurentb8ba0a92011-08-07 16:32:26 -07001629 status_t status = initCheck();
1630 if (status == NO_ERROR) {
Steve Blockdf64d152012-01-04 20:05:49 +00001631 ALOGI("AudioFlinger's thread %p ready to run", this);
Eric Laurentb8ba0a92011-08-07 16:32:26 -07001632 } else {
Steve Block29357bc2012-01-06 19:20:56 +00001633 ALOGE("No working audio driver found.");
Mathias Agopian65ab4712010-07-14 17:59:35 -07001634 }
Eric Laurentb8ba0a92011-08-07 16:32:26 -07001635 return status;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001636}
1637
1638void AudioFlinger::PlaybackThread::onFirstRef()
1639{
Eric Laurentfeb0db62011-07-22 09:04:31 -07001640 run(mName, ANDROID_PRIORITY_URGENT_AUDIO);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001641}
1642
1643// PlaybackThread::createTrack_l() must be called with AudioFlinger::mLock held
Glenn Kastenea7939a2012-03-14 12:56:26 -07001644sp<AudioFlinger::PlaybackThread::Track> AudioFlinger::PlaybackThread::createTrack_l(
Mathias Agopian65ab4712010-07-14 17:59:35 -07001645 const sp<AudioFlinger::Client>& client,
Glenn Kastenfff6d712012-01-12 16:38:12 -08001646 audio_stream_type_t streamType,
Mathias Agopian65ab4712010-07-14 17:59:35 -07001647 uint32_t sampleRate,
Glenn Kasten58f30212012-01-12 12:27:51 -08001648 audio_format_t format,
Jean-Michel Trivi0d255b22011-05-24 15:53:33 -07001649 uint32_t channelMask,
Mathias Agopian65ab4712010-07-14 17:59:35 -07001650 int frameCount,
1651 const sp<IMemory>& sharedBuffer,
1652 int sessionId,
Glenn Kasten73d22752012-03-19 13:38:30 -07001653 IAudioFlinger::track_flags_t flags,
Glenn Kasten3acbd052012-02-28 10:39:56 -08001654 pid_t tid,
Mathias Agopian65ab4712010-07-14 17:59:35 -07001655 status_t *status)
1656{
1657 sp<Track> track;
1658 status_t lStatus;
1659
Glenn Kasten73d22752012-03-19 13:38:30 -07001660 bool isTimed = (flags & IAudioFlinger::TRACK_TIMED) != 0;
1661
1662 // client expresses a preference for FAST, but we get the final say
Glenn Kastene0fa4672012-04-24 14:35:14 -07001663 if (flags & IAudioFlinger::TRACK_FAST) {
1664 if (
Glenn Kasten73d22752012-03-19 13:38:30 -07001665 // not timed
1666 (!isTimed) &&
1667 // either of these use cases:
1668 (
1669 // use case 1: shared buffer with any frame count
1670 (
1671 (sharedBuffer != 0)
1672 ) ||
Glenn Kastene0fa4672012-04-24 14:35:14 -07001673 // use case 2: callback handler and frame count is default or at least as large as HAL
Glenn Kasten73d22752012-03-19 13:38:30 -07001674 (
Glenn Kasten3acbd052012-02-28 10:39:56 -08001675 (tid != -1) &&
Glenn Kastene0fa4672012-04-24 14:35:14 -07001676 ((frameCount == 0) ||
Glenn Kasten300a2ee2012-04-25 13:47:36 -07001677 (frameCount >= (int) (mFrameCount * 2))) // * 2 is due to SRC jitter, see below
Glenn Kasten73d22752012-03-19 13:38:30 -07001678 )
1679 ) &&
1680 // PCM data
1681 audio_is_linear_pcm(format) &&
1682 // mono or stereo
1683 ( (channelMask == AUDIO_CHANNEL_OUT_MONO) ||
1684 (channelMask == AUDIO_CHANNEL_OUT_STEREO) ) &&
Glenn Kasten58912562012-04-03 10:45:00 -07001685#ifndef FAST_TRACKS_AT_NON_NATIVE_SAMPLE_RATE
Glenn Kasten73d22752012-03-19 13:38:30 -07001686 // hardware sample rate
Glenn Kasten58912562012-04-03 10:45:00 -07001687 (sampleRate == mSampleRate) &&
1688#endif
1689 // normal mixer has an associated fast mixer
1690 hasFastMixer() &&
1691 // there are sufficient fast track slots available
1692 (mFastTrackAvailMask != 0)
Glenn Kasten73d22752012-03-19 13:38:30 -07001693 // FIXME test that MixerThread for this fast track has a capable output HAL
1694 // FIXME add a permission test also?
Glenn Kastene0fa4672012-04-24 14:35:14 -07001695 ) {
Glenn Kastene0fa4672012-04-24 14:35:14 -07001696 // if frameCount not specified, then it defaults to fast mixer (HAL) frame count
1697 if (frameCount == 0) {
Glenn Kasten300a2ee2012-04-25 13:47:36 -07001698 frameCount = mFrameCount * 2; // FIXME * 2 is due to SRC jitter, should be computed
Glenn Kastene0fa4672012-04-24 14:35:14 -07001699 }
Glenn Kasten31dfd1d2012-05-01 11:07:08 -07001700 ALOGV("AUDIO_OUTPUT_FLAG_FAST accepted: frameCount=%d mFrameCount=%d",
Glenn Kasten300a2ee2012-04-25 13:47:36 -07001701 frameCount, mFrameCount);
Glenn Kastene0fa4672012-04-24 14:35:14 -07001702 } else {
1703 ALOGW("AUDIO_OUTPUT_FLAG_FAST denied: isTimed=%d sharedBuffer=%p frameCount=%d "
Glenn Kasten58912562012-04-03 10:45:00 -07001704 "mFrameCount=%d format=%d isLinear=%d channelMask=%d sampleRate=%d mSampleRate=%d "
1705 "hasFastMixer=%d tid=%d fastTrackAvailMask=%#x",
1706 isTimed, sharedBuffer.get(), frameCount, mFrameCount, format,
1707 audio_is_linear_pcm(format),
1708 channelMask, sampleRate, mSampleRate, hasFastMixer(), tid, mFastTrackAvailMask);
Glenn Kasten73d22752012-03-19 13:38:30 -07001709 flags &= ~IAudioFlinger::TRACK_FAST;
Glenn Kastene0fa4672012-04-24 14:35:14 -07001710 // For compatibility with AudioTrack calculation, buffer depth is forced
1711 // to be at least 2 x the normal mixer frame count and cover audio hardware latency.
1712 // This is probably too conservative, but legacy application code may depend on it.
1713 // If you change this calculation, also review the start threshold which is related.
1714 uint32_t latencyMs = mOutput->stream->get_latency(mOutput->stream);
1715 uint32_t minBufCount = latencyMs / ((1000 * mNormalFrameCount) / mSampleRate);
1716 if (minBufCount < 2) {
1717 minBufCount = 2;
Glenn Kasten58912562012-04-03 10:45:00 -07001718 }
Glenn Kastene0fa4672012-04-24 14:35:14 -07001719 int minFrameCount = mNormalFrameCount * minBufCount;
1720 if (frameCount < minFrameCount) {
1721 frameCount = minFrameCount;
1722 }
1723 }
Glenn Kasten73d22752012-03-19 13:38:30 -07001724 }
1725
Mathias Agopian65ab4712010-07-14 17:59:35 -07001726 if (mType == DIRECT) {
Jean-Michel Trivi0d255b22011-05-24 15:53:33 -07001727 if ((format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_PCM) {
1728 if (sampleRate != mSampleRate || format != mFormat || channelMask != mChannelMask) {
Steve Block29357bc2012-01-06 19:20:56 +00001729 ALOGE("createTrack_l() Bad parameter: sampleRate %d format %d, channelMask 0x%08x \""
Jean-Michel Trivi0d255b22011-05-24 15:53:33 -07001730 "for output %p with format %d",
1731 sampleRate, format, channelMask, mOutput, mFormat);
1732 lStatus = BAD_VALUE;
1733 goto Exit;
1734 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001735 }
1736 } else {
1737 // Resampler implementation limits input sampling rate to 2 x output sampling rate.
1738 if (sampleRate > mSampleRate*2) {
Steve Block29357bc2012-01-06 19:20:56 +00001739 ALOGE("Sample rate out of range: %d mSampleRate %d", sampleRate, mSampleRate);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001740 lStatus = BAD_VALUE;
1741 goto Exit;
1742 }
1743 }
1744
Eric Laurent7c7f10b2011-06-17 21:29:58 -07001745 lStatus = initCheck();
1746 if (lStatus != NO_ERROR) {
Steve Block29357bc2012-01-06 19:20:56 +00001747 ALOGE("Audio driver not initialized.");
Mathias Agopian65ab4712010-07-14 17:59:35 -07001748 goto Exit;
1749 }
1750
1751 { // scope for mLock
1752 Mutex::Autolock _l(mLock);
Eric Laurentde070132010-07-13 04:45:46 -07001753
1754 // all tracks in same audio session must share the same routing strategy otherwise
1755 // conflicts will happen when tracks are moved from one output to another by audio policy
1756 // manager
Glenn Kasten02bbd202012-02-08 12:35:35 -08001757 uint32_t strategy = AudioSystem::getStrategyForStream(streamType);
Eric Laurentde070132010-07-13 04:45:46 -07001758 for (size_t i = 0; i < mTracks.size(); ++i) {
1759 sp<Track> t = mTracks[i];
Glenn Kasten639dbee2012-03-07 12:26:34 -08001760 if (t != 0 && !t->isOutputTrack()) {
Glenn Kasten02bbd202012-02-08 12:35:35 -08001761 uint32_t actual = AudioSystem::getStrategyForStream(t->streamType());
Glenn Kastend8796012011-10-28 10:31:42 -07001762 if (sessionId == t->sessionId() && strategy != actual) {
Steve Block29357bc2012-01-06 19:20:56 +00001763 ALOGE("createTrack_l() mismatched strategy; expected %u but found %u",
Glenn Kastend8796012011-10-28 10:31:42 -07001764 strategy, actual);
Eric Laurentde070132010-07-13 04:45:46 -07001765 lStatus = BAD_VALUE;
1766 goto Exit;
1767 }
1768 }
1769 }
1770
John Grossman4ff14ba2012-02-08 16:37:41 -08001771 if (!isTimed) {
1772 track = new Track(this, client, streamType, sampleRate, format,
Glenn Kasten73d22752012-03-19 13:38:30 -07001773 channelMask, frameCount, sharedBuffer, sessionId, flags);
John Grossman4ff14ba2012-02-08 16:37:41 -08001774 } else {
1775 track = TimedTrack::create(this, client, streamType, sampleRate, format,
1776 channelMask, frameCount, sharedBuffer, sessionId);
1777 }
1778 if (track == NULL || track->getCblk() == NULL || track->name() < 0) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001779 lStatus = NO_MEMORY;
1780 goto Exit;
1781 }
1782 mTracks.add(track);
1783
1784 sp<EffectChain> chain = getEffectChain_l(sessionId);
1785 if (chain != 0) {
Steve Block3856b092011-10-20 11:56:00 +01001786 ALOGV("createTrack_l() setting main buffer %p", chain->inBuffer());
Mathias Agopian65ab4712010-07-14 17:59:35 -07001787 track->setMainBuffer(chain->inBuffer());
Glenn Kasten02bbd202012-02-08 12:35:35 -08001788 chain->setStrategy(AudioSystem::getStrategyForStream(track->streamType()));
Eric Laurentb469b942011-05-09 12:09:06 -07001789 chain->incTrackCnt();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001790 }
1791 }
Glenn Kasten3acbd052012-02-28 10:39:56 -08001792
1793#ifdef HAVE_REQUEST_PRIORITY
1794 if ((flags & IAudioFlinger::TRACK_FAST) && (tid != -1)) {
1795 pid_t callingPid = IPCThreadState::self()->getCallingPid();
1796 // we don't have CAP_SYS_NICE, nor do we want to have it as it's too powerful,
1797 // so ask activity manager to do this on our behalf
1798 int err = requestPriority(callingPid, tid, 1);
1799 if (err != 0) {
1800 ALOGW("Policy SCHED_FIFO priority %d is unavailable for pid %d tid %d; error %d",
1801 1, callingPid, tid, err);
1802 }
1803 }
1804#endif
1805
Mathias Agopian65ab4712010-07-14 17:59:35 -07001806 lStatus = NO_ERROR;
1807
1808Exit:
Glenn Kastene53b9ea2012-03-12 16:29:55 -07001809 if (status) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001810 *status = lStatus;
1811 }
1812 return track;
1813}
1814
Eric Laurente737cda2012-05-22 18:55:44 -07001815uint32_t AudioFlinger::MixerThread::correctLatency(uint32_t latency) const
1816{
1817 if (mFastMixer != NULL) {
1818 MonoPipe *pipe = (MonoPipe *)mPipeSink.get();
1819 latency += (pipe->getAvgFrames() * 1000) / mSampleRate;
1820 }
1821 return latency;
1822}
1823
1824uint32_t AudioFlinger::PlaybackThread::correctLatency(uint32_t latency) const
1825{
1826 return latency;
1827}
1828
Mathias Agopian65ab4712010-07-14 17:59:35 -07001829uint32_t AudioFlinger::PlaybackThread::latency() const
1830{
Eric Laurentb8ba0a92011-08-07 16:32:26 -07001831 Mutex::Autolock _l(mLock);
Marco Nelissenf06c2ed2012-06-06 09:52:31 -07001832 return latency_l();
1833}
1834uint32_t AudioFlinger::PlaybackThread::latency_l() const
1835{
Eric Laurentb8ba0a92011-08-07 16:32:26 -07001836 if (initCheck() == NO_ERROR) {
Eric Laurente737cda2012-05-22 18:55:44 -07001837 return correctLatency(mOutput->stream->get_latency(mOutput->stream));
Eric Laurentb8ba0a92011-08-07 16:32:26 -07001838 } else {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001839 return 0;
1840 }
1841}
1842
Glenn Kasten6637baa2012-01-09 09:40:36 -08001843void AudioFlinger::PlaybackThread::setMasterVolume(float value)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001844{
Glenn Kasten6637baa2012-01-09 09:40:36 -08001845 Mutex::Autolock _l(mLock);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001846 mMasterVolume = value;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001847}
1848
Glenn Kasten6637baa2012-01-09 09:40:36 -08001849void AudioFlinger::PlaybackThread::setMasterMute(bool muted)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001850{
Glenn Kasten6637baa2012-01-09 09:40:36 -08001851 Mutex::Autolock _l(mLock);
1852 setMasterMute_l(muted);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001853}
1854
Glenn Kasten6637baa2012-01-09 09:40:36 -08001855void AudioFlinger::PlaybackThread::setStreamVolume(audio_stream_type_t stream, float value)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001856{
Glenn Kasten6637baa2012-01-09 09:40:36 -08001857 Mutex::Autolock _l(mLock);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001858 mStreamTypes[stream].volume = value;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001859}
1860
Glenn Kasten6637baa2012-01-09 09:40:36 -08001861void AudioFlinger::PlaybackThread::setStreamMute(audio_stream_type_t stream, bool muted)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001862{
Glenn Kasten6637baa2012-01-09 09:40:36 -08001863 Mutex::Autolock _l(mLock);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001864 mStreamTypes[stream].mute = muted;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001865}
1866
Glenn Kastenfff6d712012-01-12 16:38:12 -08001867float AudioFlinger::PlaybackThread::streamVolume(audio_stream_type_t stream) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07001868{
Glenn Kasten6637baa2012-01-09 09:40:36 -08001869 Mutex::Autolock _l(mLock);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001870 return mStreamTypes[stream].volume;
1871}
1872
Mathias Agopian65ab4712010-07-14 17:59:35 -07001873// addTrack_l() must be called with ThreadBase::mLock held
1874status_t AudioFlinger::PlaybackThread::addTrack_l(const sp<Track>& track)
1875{
1876 status_t status = ALREADY_EXISTS;
1877
1878 // set retry count for buffer fill
1879 track->mRetryCount = kMaxTrackStartupRetries;
1880 if (mActiveTracks.indexOf(track) < 0) {
1881 // the track is newly added, make sure it fills up all its
1882 // buffers before playing. This is to ensure the client will
1883 // effectively get the latency it requested.
1884 track->mFillingUpStatus = Track::FS_FILLING;
1885 track->mResetDone = false;
Eric Laurent29864602012-05-08 18:57:51 -07001886 track->mPresentationCompleteFrames = 0;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001887 mActiveTracks.add(track);
1888 if (track->mainBuffer() != mMixBuffer) {
1889 sp<EffectChain> chain = getEffectChain_l(track->sessionId());
1890 if (chain != 0) {
Steve Block3856b092011-10-20 11:56:00 +01001891 ALOGV("addTrack_l() starting track on chain %p for session %d", chain.get(), track->sessionId());
Eric Laurentb469b942011-05-09 12:09:06 -07001892 chain->incActiveTrackCnt();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001893 }
1894 }
1895
1896 status = NO_ERROR;
1897 }
1898
Steve Block3856b092011-10-20 11:56:00 +01001899 ALOGV("mWaitWorkCV.broadcast");
Mathias Agopian65ab4712010-07-14 17:59:35 -07001900 mWaitWorkCV.broadcast();
1901
1902 return status;
1903}
1904
1905// destroyTrack_l() must be called with ThreadBase::mLock held
1906void AudioFlinger::PlaybackThread::destroyTrack_l(const sp<Track>& track)
1907{
1908 track->mState = TrackBase::TERMINATED;
Glenn Kasten288ed212012-04-25 17:52:27 -07001909 // active tracks are removed by threadLoop()
Mathias Agopian65ab4712010-07-14 17:59:35 -07001910 if (mActiveTracks.indexOf(track) < 0) {
Eric Laurentb469b942011-05-09 12:09:06 -07001911 removeTrack_l(track);
1912 }
1913}
1914
1915void AudioFlinger::PlaybackThread::removeTrack_l(const sp<Track>& track)
1916{
Eric Laurent29864602012-05-08 18:57:51 -07001917 track->triggerEvents(AudioSystem::SYNC_EVENT_PRESENTATION_COMPLETE);
Eric Laurentb469b942011-05-09 12:09:06 -07001918 mTracks.remove(track);
1919 deleteTrackName_l(track->name());
Glenn Kasten288ed212012-04-25 17:52:27 -07001920 // redundant as track is about to be destroyed, for dumpsys only
1921 track->mName = -1;
1922 if (track->isFastTrack()) {
1923 int index = track->mFastIndex;
Eric Laurent29864602012-05-08 18:57:51 -07001924 ALOG_ASSERT(0 < index && index < (int)FastMixerState::kMaxFastTracks);
Glenn Kasten288ed212012-04-25 17:52:27 -07001925 ALOG_ASSERT(!(mFastTrackAvailMask & (1 << index)));
1926 mFastTrackAvailMask |= 1 << index;
1927 // redundant as track is about to be destroyed, for dumpsys only
1928 track->mFastIndex = -1;
1929 }
Eric Laurentb469b942011-05-09 12:09:06 -07001930 sp<EffectChain> chain = getEffectChain_l(track->sessionId());
1931 if (chain != 0) {
1932 chain->decTrackCnt();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001933 }
1934}
1935
1936String8 AudioFlinger::PlaybackThread::getParameters(const String8& keys)
1937{
Eric Laurentb8ba0a92011-08-07 16:32:26 -07001938 String8 out_s8 = String8("");
Dima Zavinfce7a472011-04-19 22:30:36 -07001939 char *s;
1940
Eric Laurentb8ba0a92011-08-07 16:32:26 -07001941 Mutex::Autolock _l(mLock);
1942 if (initCheck() != NO_ERROR) {
1943 return out_s8;
1944 }
1945
Dima Zavin799a70e2011-04-18 16:57:27 -07001946 s = mOutput->stream->common.get_parameters(&mOutput->stream->common, keys.string());
Dima Zavinfce7a472011-04-19 22:30:36 -07001947 out_s8 = String8(s);
1948 free(s);
1949 return out_s8;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001950}
1951
Eric Laurentb8ba0a92011-08-07 16:32:26 -07001952// audioConfigChanged_l() must be called with AudioFlinger::mLock held
Mathias Agopian65ab4712010-07-14 17:59:35 -07001953void AudioFlinger::PlaybackThread::audioConfigChanged_l(int event, int param) {
1954 AudioSystem::OutputDescriptor desc;
Glenn Kastena0d68332012-01-27 16:47:15 -08001955 void *param2 = NULL;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001956
Steve Block3856b092011-10-20 11:56:00 +01001957 ALOGV("PlaybackThread::audioConfigChanged_l, thread %p, event %d, param %d", this, event, param);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001958
1959 switch (event) {
1960 case AudioSystem::OUTPUT_OPENED:
1961 case AudioSystem::OUTPUT_CONFIG_CHANGED:
Jean-Michel Trivi0d255b22011-05-24 15:53:33 -07001962 desc.channels = mChannelMask;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001963 desc.samplingRate = mSampleRate;
1964 desc.format = mFormat;
Glenn Kasten58912562012-04-03 10:45:00 -07001965 desc.frameCount = mNormalFrameCount; // FIXME see AudioFlinger::frameCount(audio_io_handle_t)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001966 desc.latency = latency();
1967 param2 = &desc;
1968 break;
1969
1970 case AudioSystem::STREAM_CONFIG_CHANGED:
1971 param2 = &param;
1972 case AudioSystem::OUTPUT_CLOSED:
1973 default:
1974 break;
1975 }
1976 mAudioFlinger->audioConfigChanged_l(event, mId, param2);
1977}
1978
1979void AudioFlinger::PlaybackThread::readOutputParameters()
1980{
Dima Zavin799a70e2011-04-18 16:57:27 -07001981 mSampleRate = mOutput->stream->common.get_sample_rate(&mOutput->stream->common);
Jean-Michel Trivi0d255b22011-05-24 15:53:33 -07001982 mChannelMask = mOutput->stream->common.get_channels(&mOutput->stream->common);
1983 mChannelCount = (uint16_t)popcount(mChannelMask);
Dima Zavin799a70e2011-04-18 16:57:27 -07001984 mFormat = mOutput->stream->common.get_format(&mOutput->stream->common);
Glenn Kastenb9980652012-01-11 09:48:27 -08001985 mFrameSize = audio_stream_frame_size(&mOutput->stream->common);
Dima Zavin799a70e2011-04-18 16:57:27 -07001986 mFrameCount = mOutput->stream->common.get_buffer_size(&mOutput->stream->common) / mFrameSize;
Glenn Kasten58912562012-04-03 10:45:00 -07001987 if (mFrameCount & 15) {
1988 ALOGW("HAL output buffer size is %u frames but AudioMixer requires multiples of 16 frames",
1989 mFrameCount);
1990 }
1991
Glenn Kasten300a2ee2012-04-25 13:47:36 -07001992 // Calculate size of normal mix buffer relative to the HAL output buffer size
Glenn Kasten4adcede2012-05-14 12:26:02 -07001993 double multiplier = 1.0;
Glenn Kasten300a2ee2012-04-25 13:47:36 -07001994 if (mType == MIXER && (kUseFastMixer == FastMixer_Static || kUseFastMixer == FastMixer_Dynamic)) {
Glenn Kasten58912562012-04-03 10:45:00 -07001995 size_t minNormalFrameCount = (kMinNormalMixBufferSizeMs * mSampleRate) / 1000;
Glenn Kasten4adcede2012-05-14 12:26:02 -07001996 size_t maxNormalFrameCount = (kMaxNormalMixBufferSizeMs * mSampleRate) / 1000;
1997 // round up minimum and round down maximum to nearest 16 frames to satisfy AudioMixer
1998 minNormalFrameCount = (minNormalFrameCount + 15) & ~15;
1999 maxNormalFrameCount = maxNormalFrameCount & ~15;
2000 if (maxNormalFrameCount < minNormalFrameCount) {
2001 maxNormalFrameCount = minNormalFrameCount;
2002 }
2003 multiplier = (double) minNormalFrameCount / (double) mFrameCount;
2004 if (multiplier <= 1.0) {
2005 multiplier = 1.0;
2006 } else if (multiplier <= 2.0) {
2007 if (2 * mFrameCount <= maxNormalFrameCount) {
2008 multiplier = 2.0;
2009 } else {
2010 multiplier = (double) maxNormalFrameCount / (double) mFrameCount;
2011 }
2012 } else {
2013 // prefer an even multiplier, for compatibility with doubling of fast tracks due to HAL SRC
2014 // (it would be unusual for the normal mix buffer size to not be a multiple of fast
2015 // track, but we sometimes have to do this to satisfy the maximum frame count constraint)
2016 // FIXME this rounding up should not be done if no HAL SRC
2017 uint32_t truncMult = (uint32_t) multiplier;
2018 if ((truncMult & 1)) {
2019 if ((truncMult + 1) * mFrameCount <= maxNormalFrameCount) {
2020 ++truncMult;
2021 }
2022 }
2023 multiplier = (double) truncMult;
Glenn Kasten58912562012-04-03 10:45:00 -07002024 }
Glenn Kasten58912562012-04-03 10:45:00 -07002025 }
Glenn Kasten4adcede2012-05-14 12:26:02 -07002026 mNormalFrameCount = multiplier * mFrameCount;
2027 // round up to nearest 16 frames to satisfy AudioMixer
2028 mNormalFrameCount = (mNormalFrameCount + 15) & ~15;
Glenn Kasten58912562012-04-03 10:45:00 -07002029 ALOGI("HAL output buffer size %u frames, normal mix buffer size %u frames", mFrameCount, mNormalFrameCount);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002030
Glenn Kastene9dd0172012-01-27 18:08:45 -08002031 delete[] mMixBuffer;
Eric Laurent67c0a582012-05-01 19:31:12 -07002032 mMixBuffer = new int16_t[mNormalFrameCount * mChannelCount];
2033 memset(mMixBuffer, 0, mNormalFrameCount * mChannelCount * sizeof(int16_t));
Mathias Agopian65ab4712010-07-14 17:59:35 -07002034
Eric Laurentde070132010-07-13 04:45:46 -07002035 // force reconfiguration of effect chains and engines to take new buffer size and audio
2036 // parameters into account
2037 // Note that mLock is not held when readOutputParameters() is called from the constructor
2038 // but in this case nothing is done below as no audio sessions have effect yet so it doesn't
2039 // matter.
2040 // create a copy of mEffectChains as calling moveEffectChain_l() can reorder some effect chains
2041 Vector< sp<EffectChain> > effectChains = mEffectChains;
2042 for (size_t i = 0; i < effectChains.size(); i ++) {
Eric Laurent39e94f82010-07-28 01:32:47 -07002043 mAudioFlinger->moveEffectChain_l(effectChains[i]->sessionId(), this, this, false);
Eric Laurentde070132010-07-13 04:45:46 -07002044 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002045}
2046
Eric Laurente737cda2012-05-22 18:55:44 -07002047
Mathias Agopian65ab4712010-07-14 17:59:35 -07002048status_t AudioFlinger::PlaybackThread::getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames)
2049{
Glenn Kastena0d68332012-01-27 16:47:15 -08002050 if (halFrames == NULL || dspFrames == NULL) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07002051 return BAD_VALUE;
2052 }
Eric Laurentb8ba0a92011-08-07 16:32:26 -07002053 Mutex::Autolock _l(mLock);
Eric Laurent7c7f10b2011-06-17 21:29:58 -07002054 if (initCheck() != NO_ERROR) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07002055 return INVALID_OPERATION;
2056 }
Dima Zavin799a70e2011-04-18 16:57:27 -07002057 *halFrames = mBytesWritten / audio_stream_frame_size(&mOutput->stream->common);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002058
Dima Zavin799a70e2011-04-18 16:57:27 -07002059 return mOutput->stream->get_render_position(mOutput->stream, dspFrames);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002060}
2061
Eric Laurent39e94f82010-07-28 01:32:47 -07002062uint32_t AudioFlinger::PlaybackThread::hasAudioSession(int sessionId)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002063{
2064 Mutex::Autolock _l(mLock);
Eric Laurent39e94f82010-07-28 01:32:47 -07002065 uint32_t result = 0;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002066 if (getEffectChain_l(sessionId) != 0) {
Eric Laurent39e94f82010-07-28 01:32:47 -07002067 result = EFFECT_SESSION;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002068 }
2069
2070 for (size_t i = 0; i < mTracks.size(); ++i) {
2071 sp<Track> track = mTracks[i];
Eric Laurentde070132010-07-13 04:45:46 -07002072 if (sessionId == track->sessionId() &&
2073 !(track->mCblk->flags & CBLK_INVALID_MSK)) {
Eric Laurent39e94f82010-07-28 01:32:47 -07002074 result |= TRACK_SESSION;
2075 break;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002076 }
2077 }
2078
Eric Laurent39e94f82010-07-28 01:32:47 -07002079 return result;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002080}
2081
Eric Laurentde070132010-07-13 04:45:46 -07002082uint32_t AudioFlinger::PlaybackThread::getStrategyForSession_l(int sessionId)
2083{
Dima Zavinfce7a472011-04-19 22:30:36 -07002084 // session AUDIO_SESSION_OUTPUT_MIX is placed in same strategy as MUSIC stream so that
Eric Laurentde070132010-07-13 04:45:46 -07002085 // it is moved to correct output by audio policy manager when A2DP is connected or disconnected
Dima Zavinfce7a472011-04-19 22:30:36 -07002086 if (sessionId == AUDIO_SESSION_OUTPUT_MIX) {
2087 return AudioSystem::getStrategyForStream(AUDIO_STREAM_MUSIC);
Eric Laurentde070132010-07-13 04:45:46 -07002088 }
2089 for (size_t i = 0; i < mTracks.size(); i++) {
2090 sp<Track> track = mTracks[i];
2091 if (sessionId == track->sessionId() &&
2092 !(track->mCblk->flags & CBLK_INVALID_MSK)) {
Glenn Kasten02bbd202012-02-08 12:35:35 -08002093 return AudioSystem::getStrategyForStream(track->streamType());
Eric Laurentde070132010-07-13 04:45:46 -07002094 }
2095 }
Dima Zavinfce7a472011-04-19 22:30:36 -07002096 return AudioSystem::getStrategyForStream(AUDIO_STREAM_MUSIC);
Eric Laurentde070132010-07-13 04:45:46 -07002097}
2098
Mathias Agopian65ab4712010-07-14 17:59:35 -07002099
Glenn Kastenaed850d2012-01-26 09:46:34 -08002100AudioFlinger::AudioStreamOut* AudioFlinger::PlaybackThread::getOutput() const
Eric Laurentb8ba0a92011-08-07 16:32:26 -07002101{
2102 Mutex::Autolock _l(mLock);
2103 return mOutput;
2104}
2105
2106AudioFlinger::AudioStreamOut* AudioFlinger::PlaybackThread::clearOutput()
2107{
2108 Mutex::Autolock _l(mLock);
2109 AudioStreamOut *output = mOutput;
2110 mOutput = NULL;
Glenn Kasten58912562012-04-03 10:45:00 -07002111 // FIXME FastMixer might also have a raw ptr to mOutputSink;
2112 // must push a NULL and wait for ack
2113 mOutputSink.clear();
2114 mPipeSink.clear();
2115 mNormalSink.clear();
Eric Laurentb8ba0a92011-08-07 16:32:26 -07002116 return output;
2117}
2118
2119// this method must always be called either with ThreadBase mLock held or inside the thread loop
Glenn Kasten0bf65bd2012-02-28 18:32:53 -08002120audio_stream_t* AudioFlinger::PlaybackThread::stream() const
Eric Laurentb8ba0a92011-08-07 16:32:26 -07002121{
2122 if (mOutput == NULL) {
2123 return NULL;
2124 }
2125 return &mOutput->stream->common;
2126}
2127
Glenn Kasten0bf65bd2012-02-28 18:32:53 -08002128uint32_t AudioFlinger::PlaybackThread::activeSleepTimeUs() const
Eric Laurent162b40b2011-12-05 09:47:19 -08002129{
Eric Laurentab9071b2012-06-04 13:45:29 -07002130 return (uint32_t)((uint32_t)((mNormalFrameCount * 1000) / mSampleRate) * 1000);
Eric Laurent162b40b2011-12-05 09:47:19 -08002131}
2132
Eric Laurenta011e352012-03-29 15:51:43 -07002133status_t AudioFlinger::PlaybackThread::setSyncEvent(const sp<SyncEvent>& event)
2134{
2135 if (!isValidSyncEvent(event)) {
2136 return BAD_VALUE;
2137 }
2138
2139 Mutex::Autolock _l(mLock);
2140
2141 for (size_t i = 0; i < mTracks.size(); ++i) {
2142 sp<Track> track = mTracks[i];
2143 if (event->triggerSession() == track->sessionId()) {
2144 track->setSyncEvent(event);
2145 return NO_ERROR;
2146 }
2147 }
2148
2149 return NAME_NOT_FOUND;
2150}
2151
2152bool AudioFlinger::PlaybackThread::isValidSyncEvent(const sp<SyncEvent>& event)
2153{
2154 switch (event->type()) {
2155 case AudioSystem::SYNC_EVENT_PRESENTATION_COMPLETE:
2156 return true;
2157 default:
2158 break;
2159 }
2160 return false;
2161}
2162
Eric Laurent44a957f2012-05-15 15:26:05 -07002163void AudioFlinger::PlaybackThread::threadLoop_removeTracks(const Vector< sp<Track> >& tracksToRemove)
2164{
2165 size_t count = tracksToRemove.size();
2166 if (CC_UNLIKELY(count)) {
2167 for (size_t i = 0 ; i < count ; i++) {
2168 const sp<Track>& track = tracksToRemove.itemAt(i);
2169 if ((track->sharedBuffer() != 0) &&
2170 (track->mState == TrackBase::ACTIVE || track->mState == TrackBase::RESUMING)) {
2171 AudioSystem::stopOutput(mId, track->streamType(), track->sessionId());
2172 }
2173 }
2174 }
2175
2176}
2177
Mathias Agopian65ab4712010-07-14 17:59:35 -07002178// ----------------------------------------------------------------------------
2179
Glenn Kasten23bb8be2012-01-26 10:38:26 -08002180AudioFlinger::MixerThread::MixerThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002181 audio_io_handle_t id, uint32_t device, type_t type)
Glenn Kasten58912562012-04-03 10:45:00 -07002182 : PlaybackThread(audioFlinger, output, id, device, type),
2183 // mAudioMixer below
2184#ifdef SOAKER
2185 mSoaker(NULL),
2186#endif
2187 // mFastMixer below
2188 mFastMixerFutex(0)
2189 // mOutputSink below
2190 // mPipeSink below
2191 // mNormalSink below
Mathias Agopian65ab4712010-07-14 17:59:35 -07002192{
Glenn Kasten58912562012-04-03 10:45:00 -07002193 ALOGV("MixerThread() id=%d device=%d type=%d", id, device, type);
2194 ALOGV("mSampleRate=%d, mChannelMask=%d, mChannelCount=%d, mFormat=%d, mFrameSize=%d, "
2195 "mFrameCount=%d, mNormalFrameCount=%d",
2196 mSampleRate, mChannelMask, mChannelCount, mFormat, mFrameSize, mFrameCount,
2197 mNormalFrameCount);
2198 mAudioMixer = new AudioMixer(mNormalFrameCount, mSampleRate);
2199
Mathias Agopian65ab4712010-07-14 17:59:35 -07002200 // FIXME - Current mixer implementation only supports stereo output
2201 if (mChannelCount == 1) {
Steve Block29357bc2012-01-06 19:20:56 +00002202 ALOGE("Invalid audio hardware channel count");
Mathias Agopian65ab4712010-07-14 17:59:35 -07002203 }
Glenn Kasten58912562012-04-03 10:45:00 -07002204
2205 // create an NBAIO sink for the HAL output stream, and negotiate
2206 mOutputSink = new AudioStreamOutSink(output->stream);
2207 size_t numCounterOffers = 0;
2208 const NBAIO_Format offers[1] = {Format_from_SR_C(mSampleRate, mChannelCount)};
2209 ssize_t index = mOutputSink->negotiate(offers, 1, NULL, numCounterOffers);
2210 ALOG_ASSERT(index == 0);
2211
Glenn Kasten300a2ee2012-04-25 13:47:36 -07002212 // initialize fast mixer depending on configuration
2213 bool initFastMixer;
2214 switch (kUseFastMixer) {
2215 case FastMixer_Never:
2216 initFastMixer = false;
2217 break;
2218 case FastMixer_Always:
2219 initFastMixer = true;
2220 break;
2221 case FastMixer_Static:
2222 case FastMixer_Dynamic:
2223 initFastMixer = mFrameCount < mNormalFrameCount;
2224 break;
2225 }
2226 if (initFastMixer) {
Glenn Kasten58912562012-04-03 10:45:00 -07002227
2228 // create a MonoPipe to connect our submix to FastMixer
2229 NBAIO_Format format = mOutputSink->format();
Glenn Kasten9017e5e2012-05-15 07:39:52 -07002230 // This pipe depth compensates for scheduling latency of the normal mixer thread.
2231 // When it wakes up after a maximum latency, it runs a few cycles quickly before
2232 // finally blocking. Note the pipe implementation rounds up the request to a power of 2.
2233 MonoPipe *monoPipe = new MonoPipe(mNormalFrameCount * 4, format, true /*writeCanBlock*/);
Glenn Kasten58912562012-04-03 10:45:00 -07002234 const NBAIO_Format offers[1] = {format};
2235 size_t numCounterOffers = 0;
2236 ssize_t index = monoPipe->negotiate(offers, 1, NULL, numCounterOffers);
2237 ALOG_ASSERT(index == 0);
Glenn Kasten28ed2f92012-06-07 10:17:54 -07002238 monoPipe->setAvgFrames((mScreenState & 1) ?
2239 (monoPipe->maxFrames() * 7) / 8 : mNormalFrameCount * 2);
Glenn Kasten58912562012-04-03 10:45:00 -07002240 mPipeSink = monoPipe;
2241
Glenn Kastenfbae5da2012-05-21 09:17:20 -07002242#ifdef TEE_SINK_FRAMES
2243 // create a Pipe to archive a copy of FastMixer's output for dumpsys
2244 Pipe *teeSink = new Pipe(TEE_SINK_FRAMES, format);
2245 numCounterOffers = 0;
2246 index = teeSink->negotiate(offers, 1, NULL, numCounterOffers);
2247 ALOG_ASSERT(index == 0);
2248 mTeeSink = teeSink;
2249 PipeReader *teeSource = new PipeReader(*teeSink);
2250 numCounterOffers = 0;
2251 index = teeSource->negotiate(offers, 1, NULL, numCounterOffers);
2252 ALOG_ASSERT(index == 0);
2253 mTeeSource = teeSource;
2254#endif
2255
Glenn Kasten58912562012-04-03 10:45:00 -07002256#ifdef SOAKER
2257 // create a soaker as workaround for governor issues
2258 mSoaker = new Soaker();
2259 // FIXME Soaker should only run when needed, i.e. when FastMixer is not in COLD_IDLE
2260 mSoaker->run("Soaker", PRIORITY_LOWEST);
2261#endif
2262
2263 // create fast mixer and configure it initially with just one fast track for our submix
2264 mFastMixer = new FastMixer();
2265 FastMixerStateQueue *sq = mFastMixer->sq();
Glenn Kasten39993082012-05-31 13:40:27 -07002266#ifdef STATE_QUEUE_DUMP
2267 sq->setObserverDump(&mStateQueueObserverDump);
2268 sq->setMutatorDump(&mStateQueueMutatorDump);
2269#endif
Glenn Kasten58912562012-04-03 10:45:00 -07002270 FastMixerState *state = sq->begin();
2271 FastTrack *fastTrack = &state->mFastTracks[0];
2272 // wrap the source side of the MonoPipe to make it an AudioBufferProvider
2273 fastTrack->mBufferProvider = new SourceAudioBufferProvider(new MonoPipeReader(monoPipe));
2274 fastTrack->mVolumeProvider = NULL;
2275 fastTrack->mGeneration++;
2276 state->mFastTracksGen++;
2277 state->mTrackMask = 1;
2278 // fast mixer will use the HAL output sink
2279 state->mOutputSink = mOutputSink.get();
2280 state->mOutputSinkGen++;
2281 state->mFrameCount = mFrameCount;
2282 state->mCommand = FastMixerState::COLD_IDLE;
2283 // already done in constructor initialization list
2284 //mFastMixerFutex = 0;
2285 state->mColdFutexAddr = &mFastMixerFutex;
2286 state->mColdGen++;
2287 state->mDumpState = &mFastMixerDumpState;
Glenn Kastenfbae5da2012-05-21 09:17:20 -07002288 state->mTeeSink = mTeeSink.get();
Glenn Kasten58912562012-04-03 10:45:00 -07002289 sq->end();
2290 sq->push(FastMixerStateQueue::BLOCK_UNTIL_PUSHED);
2291
2292 // start the fast mixer
2293 mFastMixer->run("FastMixer", PRIORITY_URGENT_AUDIO);
2294#ifdef HAVE_REQUEST_PRIORITY
2295 pid_t tid = mFastMixer->getTid();
2296 int err = requestPriority(getpid_cached, tid, 2);
2297 if (err != 0) {
2298 ALOGW("Policy SCHED_FIFO priority %d is unavailable for pid %d tid %d; error %d",
2299 2, getpid_cached, tid, err);
2300 }
2301#endif
2302
2303 } else {
2304 mFastMixer = NULL;
2305 }
Glenn Kasten300a2ee2012-04-25 13:47:36 -07002306
2307 switch (kUseFastMixer) {
2308 case FastMixer_Never:
2309 case FastMixer_Dynamic:
2310 mNormalSink = mOutputSink;
2311 break;
2312 case FastMixer_Always:
2313 mNormalSink = mPipeSink;
2314 break;
2315 case FastMixer_Static:
2316 mNormalSink = initFastMixer ? mPipeSink : mOutputSink;
2317 break;
2318 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002319}
2320
2321AudioFlinger::MixerThread::~MixerThread()
2322{
Glenn Kasten58912562012-04-03 10:45:00 -07002323 if (mFastMixer != NULL) {
2324 FastMixerStateQueue *sq = mFastMixer->sq();
2325 FastMixerState *state = sq->begin();
2326 if (state->mCommand == FastMixerState::COLD_IDLE) {
2327 int32_t old = android_atomic_inc(&mFastMixerFutex);
2328 if (old == -1) {
2329 __futex_syscall3(&mFastMixerFutex, FUTEX_WAKE_PRIVATE, 1);
2330 }
2331 }
2332 state->mCommand = FastMixerState::EXIT;
2333 sq->end();
2334 sq->push(FastMixerStateQueue::BLOCK_UNTIL_PUSHED);
2335 mFastMixer->join();
2336 // Though the fast mixer thread has exited, it's state queue is still valid.
2337 // We'll use that extract the final state which contains one remaining fast track
2338 // corresponding to our sub-mix.
2339 state = sq->begin();
2340 ALOG_ASSERT(state->mTrackMask == 1);
2341 FastTrack *fastTrack = &state->mFastTracks[0];
2342 ALOG_ASSERT(fastTrack->mBufferProvider != NULL);
2343 delete fastTrack->mBufferProvider;
2344 sq->end(false /*didModify*/);
2345 delete mFastMixer;
2346#ifdef SOAKER
2347 if (mSoaker != NULL) {
2348 mSoaker->requestExitAndWait();
2349 }
2350 delete mSoaker;
2351#endif
2352 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002353 delete mAudioMixer;
2354}
2355
Glenn Kasten83efdd02012-02-24 07:21:32 -08002356class CpuStats {
2357public:
Glenn Kasten190a46f2012-03-06 11:27:10 -08002358 CpuStats();
2359 void sample(const String8 &title);
Glenn Kasten83efdd02012-02-24 07:21:32 -08002360#ifdef DEBUG_CPU_USAGE
2361private:
Glenn Kasten190a46f2012-03-06 11:27:10 -08002362 ThreadCpuUsage mCpuUsage; // instantaneous thread CPU usage in wall clock ns
2363 CentralTendencyStatistics mWcStats; // statistics on thread CPU usage in wall clock ns
2364
2365 CentralTendencyStatistics mHzStats; // statistics on thread CPU usage in cycles
2366
2367 int mCpuNum; // thread's current CPU number
2368 int mCpukHz; // frequency of thread's current CPU in kHz
Glenn Kasten83efdd02012-02-24 07:21:32 -08002369#endif
2370};
2371
Glenn Kasten190a46f2012-03-06 11:27:10 -08002372CpuStats::CpuStats()
Glenn Kasten83efdd02012-02-24 07:21:32 -08002373#ifdef DEBUG_CPU_USAGE
Glenn Kasten190a46f2012-03-06 11:27:10 -08002374 : mCpuNum(-1), mCpukHz(-1)
2375#endif
2376{
2377}
2378
2379void CpuStats::sample(const String8 &title) {
2380#ifdef DEBUG_CPU_USAGE
2381 // get current thread's delta CPU time in wall clock ns
2382 double wcNs;
2383 bool valid = mCpuUsage.sampleAndEnable(wcNs);
2384
2385 // record sample for wall clock statistics
2386 if (valid) {
2387 mWcStats.sample(wcNs);
2388 }
2389
2390 // get the current CPU number
2391 int cpuNum = sched_getcpu();
2392
2393 // get the current CPU frequency in kHz
2394 int cpukHz = mCpuUsage.getCpukHz(cpuNum);
2395
2396 // check if either CPU number or frequency changed
2397 if (cpuNum != mCpuNum || cpukHz != mCpukHz) {
2398 mCpuNum = cpuNum;
2399 mCpukHz = cpukHz;
2400 // ignore sample for purposes of cycles
2401 valid = false;
2402 }
2403
2404 // if no change in CPU number or frequency, then record sample for cycle statistics
2405 if (valid && mCpukHz > 0) {
2406 double cycles = wcNs * cpukHz * 0.000001;
2407 mHzStats.sample(cycles);
2408 }
2409
2410 unsigned n = mWcStats.n();
2411 // mCpuUsage.elapsed() is expensive, so don't call it every loop
Glenn Kasten83efdd02012-02-24 07:21:32 -08002412 if ((n & 127) == 1) {
Glenn Kasten190a46f2012-03-06 11:27:10 -08002413 long long elapsed = mCpuUsage.elapsed();
Glenn Kasten83efdd02012-02-24 07:21:32 -08002414 if (elapsed >= DEBUG_CPU_USAGE * 1000000000LL) {
2415 double perLoop = elapsed / (double) n;
2416 double perLoop100 = perLoop * 0.01;
Glenn Kasten190a46f2012-03-06 11:27:10 -08002417 double perLoop1k = perLoop * 0.001;
2418 double mean = mWcStats.mean();
2419 double stddev = mWcStats.stddev();
2420 double minimum = mWcStats.minimum();
2421 double maximum = mWcStats.maximum();
2422 double meanCycles = mHzStats.mean();
2423 double stddevCycles = mHzStats.stddev();
2424 double minCycles = mHzStats.minimum();
2425 double maxCycles = mHzStats.maximum();
2426 mCpuUsage.resetElapsed();
2427 mWcStats.reset();
2428 mHzStats.reset();
2429 ALOGD("CPU usage for %s over past %.1f secs\n"
2430 " (%u mixer loops at %.1f mean ms per loop):\n"
2431 " us per mix loop: mean=%.0f stddev=%.0f min=%.0f max=%.0f\n"
2432 " %% of wall: mean=%.1f stddev=%.1f min=%.1f max=%.1f\n"
2433 " MHz: mean=%.1f, stddev=%.1f, min=%.1f max=%.1f",
2434 title.string(),
Glenn Kasten83efdd02012-02-24 07:21:32 -08002435 elapsed * .000000001, n, perLoop * .000001,
2436 mean * .001,
2437 stddev * .001,
2438 minimum * .001,
2439 maximum * .001,
2440 mean / perLoop100,
2441 stddev / perLoop100,
2442 minimum / perLoop100,
Glenn Kasten190a46f2012-03-06 11:27:10 -08002443 maximum / perLoop100,
2444 meanCycles / perLoop1k,
2445 stddevCycles / perLoop1k,
2446 minCycles / perLoop1k,
2447 maxCycles / perLoop1k);
2448
Glenn Kasten83efdd02012-02-24 07:21:32 -08002449 }
2450 }
2451#endif
2452};
2453
Glenn Kasten37d825e2012-02-24 07:21:48 -08002454void AudioFlinger::PlaybackThread::checkSilentMode_l()
2455{
2456 if (!mMasterMute) {
2457 char value[PROPERTY_VALUE_MAX];
2458 if (property_get("ro.audio.silent", value, "0") > 0) {
2459 char *endptr;
2460 unsigned long ul = strtoul(value, &endptr, 0);
2461 if (*endptr == '\0' && ul != 0) {
2462 ALOGD("Silence is golden");
2463 // The setprop command will not allow a property to be changed after
2464 // the first time it is set, so we don't have to worry about un-muting.
2465 setMasterMute_l(true);
2466 }
2467 }
2468 }
2469}
2470
Glenn Kasten000f0e32012-03-01 17:10:56 -08002471bool AudioFlinger::PlaybackThread::threadLoop()
Mathias Agopian65ab4712010-07-14 17:59:35 -07002472{
2473 Vector< sp<Track> > tracksToRemove;
Glenn Kasten688a6402012-02-29 07:57:06 -08002474
Glenn Kasten000f0e32012-03-01 17:10:56 -08002475 standbyTime = systemTime();
Glenn Kasten000f0e32012-03-01 17:10:56 -08002476
2477 // MIXER
Mathias Agopian65ab4712010-07-14 17:59:35 -07002478 nsecs_t lastWarning = 0;
Glenn Kasten000f0e32012-03-01 17:10:56 -08002479if (mType == MIXER) {
2480 longStandbyExit = false;
2481}
Glenn Kasten688a6402012-02-29 07:57:06 -08002482
Glenn Kasten000f0e32012-03-01 17:10:56 -08002483 // DUPLICATING
2484 // FIXME could this be made local to while loop?
2485 writeFrames = 0;
Glenn Kasten688a6402012-02-29 07:57:06 -08002486
Glenn Kasten66fcab92012-02-24 14:59:21 -08002487 cacheParameters_l();
Glenn Kasten000f0e32012-03-01 17:10:56 -08002488 sleepTime = idleSleepTime;
2489
2490if (mType == MIXER) {
2491 sleepTimeShift = 0;
2492}
2493
Glenn Kasten83efdd02012-02-24 07:21:32 -08002494 CpuStats cpuStats;
Glenn Kasten190a46f2012-03-06 11:27:10 -08002495 const String8 myName(String8::format("thread %p type %d TID %d", this, mType, gettid()));
Mathias Agopian65ab4712010-07-14 17:59:35 -07002496
Eric Laurentfeb0db62011-07-22 09:04:31 -07002497 acquireWakeLock();
2498
Mathias Agopian65ab4712010-07-14 17:59:35 -07002499 while (!exitPending())
2500 {
Glenn Kasten190a46f2012-03-06 11:27:10 -08002501 cpuStats.sample(myName);
Glenn Kasten688a6402012-02-29 07:57:06 -08002502
Glenn Kasten73ca0f52012-02-29 07:56:15 -08002503 Vector< sp<EffectChain> > effectChains;
2504
Mathias Agopian65ab4712010-07-14 17:59:35 -07002505 processConfigEvents();
2506
Mathias Agopian65ab4712010-07-14 17:59:35 -07002507 { // scope for mLock
2508
2509 Mutex::Autolock _l(mLock);
2510
2511 if (checkForNewParameters_l()) {
Glenn Kasten66fcab92012-02-24 14:59:21 -08002512 cacheParameters_l();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002513 }
2514
Glenn Kastenfa26a852012-03-06 11:28:04 -08002515 saveOutputTracks();
Glenn Kasten000f0e32012-03-01 17:10:56 -08002516
Mathias Agopian65ab4712010-07-14 17:59:35 -07002517 // put audio hardware into standby after short delay
Glenn Kasten3e074702012-02-28 18:40:35 -08002518 if (CC_UNLIKELY((!mActiveTracks.size() && systemTime() > standbyTime) ||
Glenn Kastenc455fe92012-02-29 07:07:30 -08002519 mSuspended > 0)) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07002520 if (!mStandby) {
Glenn Kasten000f0e32012-03-01 17:10:56 -08002521
2522 threadLoop_standby();
2523
Mathias Agopian65ab4712010-07-14 17:59:35 -07002524 mStandby = true;
2525 mBytesWritten = 0;
2526 }
2527
Glenn Kasten3e074702012-02-28 18:40:35 -08002528 if (!mActiveTracks.size() && mConfigEvents.isEmpty()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07002529 // we're about to wait, flush the binder command buffer
2530 IPCThreadState::self()->flushCommands();
2531
Glenn Kastenfa26a852012-03-06 11:28:04 -08002532 clearOutputTracks();
Glenn Kasten000f0e32012-03-01 17:10:56 -08002533
Mathias Agopian65ab4712010-07-14 17:59:35 -07002534 if (exitPending()) break;
2535
Eric Laurentfeb0db62011-07-22 09:04:31 -07002536 releaseWakeLock_l();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002537 // wait until we have something to do...
Glenn Kasten190a46f2012-03-06 11:27:10 -08002538 ALOGV("%s going to sleep", myName.string());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002539 mWaitWorkCV.wait(mLock);
Glenn Kasten190a46f2012-03-06 11:27:10 -08002540 ALOGV("%s waking up", myName.string());
Eric Laurentfeb0db62011-07-22 09:04:31 -07002541 acquireWakeLock_l();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002542
Eric Laurentda747442012-04-25 18:53:13 -07002543 mMixerStatus = MIXER_IDLE;
Glenn Kasten81028042012-04-30 18:15:12 -07002544 mMixerStatusIgnoringFastTracks = MIXER_IDLE;
Glenn Kasten000f0e32012-03-01 17:10:56 -08002545
Glenn Kasten37d825e2012-02-24 07:21:48 -08002546 checkSilentMode_l();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002547
Glenn Kasten000f0e32012-03-01 17:10:56 -08002548 standbyTime = systemTime() + standbyDelay;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002549 sleepTime = idleSleepTime;
Glenn Kasten66fcab92012-02-24 14:59:21 -08002550 if (mType == MIXER) {
2551 sleepTimeShift = 0;
2552 }
Glenn Kasten000f0e32012-03-01 17:10:56 -08002553
Mathias Agopian65ab4712010-07-14 17:59:35 -07002554 continue;
2555 }
2556 }
2557
Glenn Kasten81028042012-04-30 18:15:12 -07002558 // mMixerStatusIgnoringFastTracks is also updated internally
Eric Laurentda747442012-04-25 18:53:13 -07002559 mMixerStatus = prepareTracks_l(&tracksToRemove);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002560
2561 // prevent any changes in effect chain list and in each effect chain
2562 // during mixing and effect process as the audio buffers could be deleted
2563 // or modified if an effect is created or deleted
Eric Laurentde070132010-07-13 04:45:46 -07002564 lockEffectChains_l(effectChains);
Glenn Kastenc5ac4cb2011-12-12 09:05:55 -08002565 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002566
Glenn Kastenfec279f2012-03-08 07:47:15 -08002567 if (CC_LIKELY(mMixerStatus == MIXER_TRACKS_READY)) {
Glenn Kasten000f0e32012-03-01 17:10:56 -08002568 threadLoop_mix();
2569 } else {
2570 threadLoop_sleepTime();
2571 }
2572
2573 if (mSuspended > 0) {
2574 sleepTime = suspendSleepTimeUs();
2575 }
2576
2577 // only process effects if we're going to write
2578 if (sleepTime == 0) {
Glenn Kasten000f0e32012-03-01 17:10:56 -08002579 for (size_t i = 0; i < effectChains.size(); i ++) {
2580 effectChains[i]->process_l();
2581 }
2582 }
2583
2584 // enable changes in effect chain
2585 unlockEffectChains(effectChains);
2586
2587 // sleepTime == 0 means we must write to audio hardware
2588 if (sleepTime == 0) {
2589
2590 threadLoop_write();
2591
2592if (mType == MIXER) {
2593 // write blocked detection
2594 nsecs_t now = systemTime();
2595 nsecs_t delta = now - mLastWriteTime;
2596 if (!mStandby && delta > maxPeriod) {
2597 mNumDelayedWrites++;
2598 if ((now - lastWarning) > kWarningThrottleNs) {
Glenn Kasten99c99d02012-05-14 16:37:13 -07002599#if defined(ATRACE_TAG) && (ATRACE_TAG != ATRACE_TAG_NEVER)
Glenn Kastend8e6fd32012-05-07 11:07:57 -07002600 ScopedTrace st(ATRACE_TAG, "underrun");
Glenn Kasten99c99d02012-05-14 16:37:13 -07002601#endif
Glenn Kasten000f0e32012-03-01 17:10:56 -08002602 ALOGW("write blocked for %llu msecs, %d delayed writes, thread %p",
2603 ns2ms(delta), mNumDelayedWrites, this);
2604 lastWarning = now;
2605 }
2606 // FIXME this is broken: longStandbyExit should be handled out of the if() and with
2607 // a different threshold. Or completely removed for what it is worth anyway...
2608 if (mStandby) {
2609 longStandbyExit = true;
2610 }
2611 }
2612}
2613
2614 mStandby = false;
2615 } else {
2616 usleep(sleepTime);
2617 }
2618
Glenn Kasten58912562012-04-03 10:45:00 -07002619 // Finally let go of removed track(s), without the lock held
Glenn Kasten000f0e32012-03-01 17:10:56 -08002620 // since we can't guarantee the destructors won't acquire that
Glenn Kasten58912562012-04-03 10:45:00 -07002621 // same lock. This will also mutate and push a new fast mixer state.
2622 threadLoop_removeTracks(tracksToRemove);
Glenn Kasten1465f0c2012-03-06 11:23:32 -08002623 tracksToRemove.clear();
Glenn Kasten000f0e32012-03-01 17:10:56 -08002624
Glenn Kastenfa26a852012-03-06 11:28:04 -08002625 // FIXME I don't understand the need for this here;
2626 // it was in the original code but maybe the
2627 // assignment in saveOutputTracks() makes this unnecessary?
2628 clearOutputTracks();
Glenn Kasten000f0e32012-03-01 17:10:56 -08002629
2630 // Effect chains will be actually deleted here if they were removed from
2631 // mEffectChains list during mixing or effects processing
2632 effectChains.clear();
2633
2634 // FIXME Note that the above .clear() is no longer necessary since effectChains
2635 // is now local to this block, but will keep it for now (at least until merge done).
2636 }
2637
2638if (mType == MIXER || mType == DIRECT) {
2639 // put output stream into standby mode
2640 if (!mStandby) {
2641 mOutput->stream->common.standby(&mOutput->stream->common);
2642 }
2643}
2644if (mType == DUPLICATING) {
2645 // for DuplicatingThread, standby mode is handled by the outputTracks
2646}
2647
2648 releaseWakeLock();
2649
2650 ALOGV("Thread %p type %d exiting", this, mType);
2651 return false;
2652}
2653
Glenn Kasten58912562012-04-03 10:45:00 -07002654void AudioFlinger::MixerThread::threadLoop_removeTracks(const Vector< sp<Track> >& tracksToRemove)
2655{
Glenn Kasten58912562012-04-03 10:45:00 -07002656 PlaybackThread::threadLoop_removeTracks(tracksToRemove);
2657}
2658
2659void AudioFlinger::MixerThread::threadLoop_write()
2660{
2661 // FIXME we should only do one push per cycle; confirm this is true
2662 // Start the fast mixer if it's not already running
2663 if (mFastMixer != NULL) {
2664 FastMixerStateQueue *sq = mFastMixer->sq();
2665 FastMixerState *state = sq->begin();
Glenn Kasten300a2ee2012-04-25 13:47:36 -07002666 if (state->mCommand != FastMixerState::MIX_WRITE &&
2667 (kUseFastMixer != FastMixer_Dynamic || state->mTrackMask > 1)) {
Glenn Kasten58912562012-04-03 10:45:00 -07002668 if (state->mCommand == FastMixerState::COLD_IDLE) {
2669 int32_t old = android_atomic_inc(&mFastMixerFutex);
2670 if (old == -1) {
2671 __futex_syscall3(&mFastMixerFutex, FUTEX_WAKE_PRIVATE, 1);
2672 }
2673 }
2674 state->mCommand = FastMixerState::MIX_WRITE;
2675 sq->end();
2676 sq->push(FastMixerStateQueue::BLOCK_UNTIL_PUSHED);
Glenn Kasten300a2ee2012-04-25 13:47:36 -07002677 if (kUseFastMixer == FastMixer_Dynamic) {
2678 mNormalSink = mPipeSink;
2679 }
Glenn Kasten58912562012-04-03 10:45:00 -07002680 } else {
2681 sq->end(false /*didModify*/);
2682 }
2683 }
2684 PlaybackThread::threadLoop_write();
2685}
2686
Glenn Kasten000f0e32012-03-01 17:10:56 -08002687// shared by MIXER and DIRECT, overridden by DUPLICATING
2688void AudioFlinger::PlaybackThread::threadLoop_write()
2689{
Glenn Kasten952eeb22012-03-06 11:30:57 -08002690 // FIXME rewrite to reduce number of system calls
2691 mLastWriteTime = systemTime();
2692 mInWrite = true;
Eric Laurent67c0a582012-05-01 19:31:12 -07002693 int bytesWritten;
Glenn Kasten58912562012-04-03 10:45:00 -07002694
Eric Laurent67c0a582012-05-01 19:31:12 -07002695 // If an NBAIO sink is present, use it to write the normal mixer's submix
2696 if (mNormalSink != 0) {
Glenn Kasten58912562012-04-03 10:45:00 -07002697#define mBitShift 2 // FIXME
Eric Laurent67c0a582012-05-01 19:31:12 -07002698 size_t count = mixBufferSize >> mBitShift;
Glenn Kasten99c99d02012-05-14 16:37:13 -07002699#if defined(ATRACE_TAG) && (ATRACE_TAG != ATRACE_TAG_NEVER)
Eric Laurent67c0a582012-05-01 19:31:12 -07002700 Tracer::traceBegin(ATRACE_TAG, "write");
Glenn Kasten99c99d02012-05-14 16:37:13 -07002701#endif
Glenn Kasten28ed2f92012-06-07 10:17:54 -07002702 // update the setpoint when gScreenState changes
2703 uint32_t screenState = gScreenState;
2704 if (screenState != mScreenState) {
2705 mScreenState = screenState;
2706 MonoPipe *pipe = (MonoPipe *)mPipeSink.get();
2707 if (pipe != NULL) {
2708 pipe->setAvgFrames((mScreenState & 1) ?
2709 (pipe->maxFrames() * 7) / 8 : mNormalFrameCount * 2);
2710 }
2711 }
Eric Laurent67c0a582012-05-01 19:31:12 -07002712 ssize_t framesWritten = mNormalSink->write(mMixBuffer, count);
Glenn Kasten99c99d02012-05-14 16:37:13 -07002713#if defined(ATRACE_TAG) && (ATRACE_TAG != ATRACE_TAG_NEVER)
Eric Laurent67c0a582012-05-01 19:31:12 -07002714 Tracer::traceEnd(ATRACE_TAG);
Glenn Kasten99c99d02012-05-14 16:37:13 -07002715#endif
Eric Laurent67c0a582012-05-01 19:31:12 -07002716 if (framesWritten > 0) {
2717 bytesWritten = framesWritten << mBitShift;
2718 } else {
2719 bytesWritten = framesWritten;
2720 }
2721 // otherwise use the HAL / AudioStreamOut directly
2722 } else {
2723 // Direct output thread.
2724 bytesWritten = (int)mOutput->stream->write(mOutput->stream, mMixBuffer, mixBufferSize);
Glenn Kasten58912562012-04-03 10:45:00 -07002725 }
2726
Eric Laurent67c0a582012-05-01 19:31:12 -07002727 if (bytesWritten > 0) mBytesWritten += mixBufferSize;
Glenn Kasten952eeb22012-03-06 11:30:57 -08002728 mNumWrites++;
2729 mInWrite = false;
Glenn Kasten000f0e32012-03-01 17:10:56 -08002730}
2731
Glenn Kasten58912562012-04-03 10:45:00 -07002732void AudioFlinger::MixerThread::threadLoop_standby()
2733{
2734 // Idle the fast mixer if it's currently running
2735 if (mFastMixer != NULL) {
2736 FastMixerStateQueue *sq = mFastMixer->sq();
2737 FastMixerState *state = sq->begin();
2738 if (!(state->mCommand & FastMixerState::IDLE)) {
2739 state->mCommand = FastMixerState::COLD_IDLE;
2740 state->mColdFutexAddr = &mFastMixerFutex;
2741 state->mColdGen++;
2742 mFastMixerFutex = 0;
2743 sq->end();
2744 // BLOCK_UNTIL_PUSHED would be insufficient, as we need it to stop doing I/O now
2745 sq->push(FastMixerStateQueue::BLOCK_UNTIL_ACKED);
Glenn Kasten300a2ee2012-04-25 13:47:36 -07002746 if (kUseFastMixer == FastMixer_Dynamic) {
2747 mNormalSink = mOutputSink;
2748 }
Glenn Kasten58912562012-04-03 10:45:00 -07002749 } else {
2750 sq->end(false /*didModify*/);
2751 }
2752 }
2753 PlaybackThread::threadLoop_standby();
2754}
2755
Glenn Kasten000f0e32012-03-01 17:10:56 -08002756// shared by MIXER and DIRECT, overridden by DUPLICATING
2757void AudioFlinger::PlaybackThread::threadLoop_standby()
2758{
Glenn Kasten952eeb22012-03-06 11:30:57 -08002759 ALOGV("Audio hardware entering standby, mixer %p, suspend count %u", this, mSuspended);
2760 mOutput->stream->common.standby(&mOutput->stream->common);
Glenn Kasten000f0e32012-03-01 17:10:56 -08002761}
2762
2763void AudioFlinger::MixerThread::threadLoop_mix()
2764{
Glenn Kasten952eeb22012-03-06 11:30:57 -08002765 // obtain the presentation timestamp of the next output buffer
2766 int64_t pts;
2767 status_t status = INVALID_OPERATION;
John Grossman4ff14ba2012-02-08 16:37:41 -08002768
Glenn Kasten952eeb22012-03-06 11:30:57 -08002769 if (NULL != mOutput->stream->get_next_write_timestamp) {
2770 status = mOutput->stream->get_next_write_timestamp(
2771 mOutput->stream, &pts);
2772 }
John Grossman4ff14ba2012-02-08 16:37:41 -08002773
Glenn Kasten952eeb22012-03-06 11:30:57 -08002774 if (status != NO_ERROR) {
2775 pts = AudioBufferProvider::kInvalidPTS;
2776 }
John Grossman4ff14ba2012-02-08 16:37:41 -08002777
Glenn Kasten952eeb22012-03-06 11:30:57 -08002778 // mix buffers...
2779 mAudioMixer->process(pts);
2780 // increase sleep time progressively when application underrun condition clears.
2781 // Only increase sleep time if the mixer is ready for two consecutive times to avoid
2782 // that a steady state of alternating ready/not ready conditions keeps the sleep time
2783 // such that we would underrun the audio HAL.
2784 if ((sleepTime == 0) && (sleepTimeShift > 0)) {
2785 sleepTimeShift--;
2786 }
2787 sleepTime = 0;
Glenn Kasten66fcab92012-02-24 14:59:21 -08002788 standbyTime = systemTime() + standbyDelay;
Glenn Kasten952eeb22012-03-06 11:30:57 -08002789 //TODO: delay standby when effects have a tail
Glenn Kasten000f0e32012-03-01 17:10:56 -08002790}
2791
2792void AudioFlinger::MixerThread::threadLoop_sleepTime()
2793{
Glenn Kasten952eeb22012-03-06 11:30:57 -08002794 // If no tracks are ready, sleep once for the duration of an output
2795 // buffer size, then write 0s to the output
2796 if (sleepTime == 0) {
Glenn Kastenfec279f2012-03-08 07:47:15 -08002797 if (mMixerStatus == MIXER_TRACKS_ENABLED) {
Glenn Kasten952eeb22012-03-06 11:30:57 -08002798 sleepTime = activeSleepTime >> sleepTimeShift;
2799 if (sleepTime < kMinThreadSleepTimeUs) {
2800 sleepTime = kMinThreadSleepTimeUs;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002801 }
Glenn Kasten952eeb22012-03-06 11:30:57 -08002802 // reduce sleep time in case of consecutive application underruns to avoid
2803 // starving the audio HAL. As activeSleepTimeUs() is larger than a buffer
2804 // duration we would end up writing less data than needed by the audio HAL if
2805 // the condition persists.
2806 if (sleepTimeShift < kMaxThreadSleepTimeShift) {
2807 sleepTimeShift++;
2808 }
2809 } else {
2810 sleepTime = idleSleepTime;
2811 }
2812 } else if (mBytesWritten != 0 ||
Glenn Kastenfec279f2012-03-08 07:47:15 -08002813 (mMixerStatus == MIXER_TRACKS_ENABLED && longStandbyExit)) {
Glenn Kasten952eeb22012-03-06 11:30:57 -08002814 memset (mMixBuffer, 0, mixBufferSize);
2815 sleepTime = 0;
Glenn Kastenfec279f2012-03-08 07:47:15 -08002816 ALOGV_IF((mBytesWritten == 0 && (mMixerStatus == MIXER_TRACKS_ENABLED && longStandbyExit)), "anticipated start");
Glenn Kasten952eeb22012-03-06 11:30:57 -08002817 }
2818 // TODO add standby time extension fct of effect tail
Mathias Agopian65ab4712010-07-14 17:59:35 -07002819}
2820
2821// prepareTracks_l() must be called with ThreadBase::mLock held
Glenn Kasten29c23c32012-01-26 13:37:52 -08002822AudioFlinger::PlaybackThread::mixer_state AudioFlinger::MixerThread::prepareTracks_l(
Glenn Kasten3e074702012-02-28 18:40:35 -08002823 Vector< sp<Track> > *tracksToRemove)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002824{
2825
Glenn Kasten29c23c32012-01-26 13:37:52 -08002826 mixer_state mixerStatus = MIXER_IDLE;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002827 // find out which tracks need to be processed
Glenn Kasten3e074702012-02-28 18:40:35 -08002828 size_t count = mActiveTracks.size();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002829 size_t mixedTracks = 0;
2830 size_t tracksWithEffect = 0;
Glenn Kasten288ed212012-04-25 17:52:27 -07002831 // counts only _active_ fast tracks
Glenn Kasten58912562012-04-03 10:45:00 -07002832 size_t fastTracks = 0;
Glenn Kasten288ed212012-04-25 17:52:27 -07002833 uint32_t resetMask = 0; // bit mask of fast tracks that need to be reset
Mathias Agopian65ab4712010-07-14 17:59:35 -07002834
2835 float masterVolume = mMasterVolume;
Glenn Kastenea7939a2012-03-14 12:56:26 -07002836 bool masterMute = mMasterMute;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002837
Eric Laurent571d49c2010-08-11 05:20:11 -07002838 if (masterMute) {
2839 masterVolume = 0;
2840 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002841 // Delegate master volume control to effect in output mix effect chain if needed
Dima Zavinfce7a472011-04-19 22:30:36 -07002842 sp<EffectChain> chain = getEffectChain_l(AUDIO_SESSION_OUTPUT_MIX);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002843 if (chain != 0) {
Eric Laurent571d49c2010-08-11 05:20:11 -07002844 uint32_t v = (uint32_t)(masterVolume * (1 << 24));
Eric Laurentcab11242010-07-15 12:50:15 -07002845 chain->setVolume_l(&v, &v);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002846 masterVolume = (float)((v + (1 << 23)) >> 24);
2847 chain.clear();
2848 }
2849
Glenn Kasten288ed212012-04-25 17:52:27 -07002850 // prepare a new state to push
2851 FastMixerStateQueue *sq = NULL;
2852 FastMixerState *state = NULL;
2853 bool didModify = false;
2854 FastMixerStateQueue::block_t block = FastMixerStateQueue::BLOCK_UNTIL_PUSHED;
2855 if (mFastMixer != NULL) {
2856 sq = mFastMixer->sq();
2857 state = sq->begin();
2858 }
2859
Mathias Agopian65ab4712010-07-14 17:59:35 -07002860 for (size_t i=0 ; i<count ; i++) {
Glenn Kasten3e074702012-02-28 18:40:35 -08002861 sp<Track> t = mActiveTracks[i].promote();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002862 if (t == 0) continue;
2863
Glenn Kasten9c56d4a2011-12-19 15:06:39 -08002864 // this const just means the local variable doesn't change
Mathias Agopian65ab4712010-07-14 17:59:35 -07002865 Track* const track = t.get();
Glenn Kasten58912562012-04-03 10:45:00 -07002866
Glenn Kasten288ed212012-04-25 17:52:27 -07002867 // process fast tracks
Glenn Kasten58912562012-04-03 10:45:00 -07002868 if (track->isFastTrack()) {
Glenn Kasten288ed212012-04-25 17:52:27 -07002869
2870 // It's theoretically possible (though unlikely) for a fast track to be created
2871 // and then removed within the same normal mix cycle. This is not a problem, as
2872 // the track never becomes active so it's fast mixer slot is never touched.
2873 // The converse, of removing an (active) track and then creating a new track
2874 // at the identical fast mixer slot within the same normal mix cycle,
2875 // is impossible because the slot isn't marked available until the end of each cycle.
2876 int j = track->mFastIndex;
Glenn Kasten893a0542012-05-30 10:32:06 -07002877 ALOG_ASSERT(0 < j && j < (int)FastMixerState::kMaxFastTracks);
2878 ALOG_ASSERT(!(mFastTrackAvailMask & (1 << j)));
Glenn Kasten288ed212012-04-25 17:52:27 -07002879 FastTrack *fastTrack = &state->mFastTracks[j];
2880
2881 // Determine whether the track is currently in underrun condition,
2882 // and whether it had a recent underrun.
Glenn Kasten1295bb4d2012-05-31 07:43:43 -07002883 FastTrackDump *ftDump = &mFastMixerDumpState.mTracks[j];
2884 FastTrackUnderruns underruns = ftDump->mUnderruns;
Glenn Kasten09474df2012-05-10 14:48:07 -07002885 uint32_t recentFull = (underruns.mBitFields.mFull -
2886 track->mObservedUnderruns.mBitFields.mFull) & UNDERRUN_MASK;
2887 uint32_t recentPartial = (underruns.mBitFields.mPartial -
2888 track->mObservedUnderruns.mBitFields.mPartial) & UNDERRUN_MASK;
2889 uint32_t recentEmpty = (underruns.mBitFields.mEmpty -
2890 track->mObservedUnderruns.mBitFields.mEmpty) & UNDERRUN_MASK;
2891 uint32_t recentUnderruns = recentPartial + recentEmpty;
2892 track->mObservedUnderruns = underruns;
Glenn Kasten288ed212012-04-25 17:52:27 -07002893 // don't count underruns that occur while stopping or pausing
Glenn Kastend08f48c2012-05-01 18:14:02 -07002894 // or stopped which can occur when flush() is called while active
2895 if (!(track->isStopping() || track->isPausing() || track->isStopped())) {
Glenn Kasten288ed212012-04-25 17:52:27 -07002896 track->mUnderrunCount += recentUnderruns;
2897 }
Glenn Kasten288ed212012-04-25 17:52:27 -07002898
Glenn Kastend08f48c2012-05-01 18:14:02 -07002899 // This is similar to the state machine for normal tracks,
Glenn Kasten288ed212012-04-25 17:52:27 -07002900 // with a few modifications for fast tracks.
Glenn Kastend08f48c2012-05-01 18:14:02 -07002901 bool isActive = true;
2902 switch (track->mState) {
2903 case TrackBase::STOPPING_1:
2904 // track stays active in STOPPING_1 state until first underrun
2905 if (recentUnderruns > 0) {
2906 track->mState = TrackBase::STOPPING_2;
2907 }
2908 break;
2909 case TrackBase::PAUSING:
Glenn Kasten288ed212012-04-25 17:52:27 -07002910 // ramp down is not yet implemented
Glenn Kasten288ed212012-04-25 17:52:27 -07002911 track->setPaused();
Glenn Kastend08f48c2012-05-01 18:14:02 -07002912 break;
2913 case TrackBase::RESUMING:
Glenn Kasten288ed212012-04-25 17:52:27 -07002914 // ramp up is not yet implemented
Glenn Kasten288ed212012-04-25 17:52:27 -07002915 track->mState = TrackBase::ACTIVE;
Glenn Kastend08f48c2012-05-01 18:14:02 -07002916 break;
2917 case TrackBase::ACTIVE:
Glenn Kasten09474df2012-05-10 14:48:07 -07002918 if (recentFull > 0 || recentPartial > 0) {
2919 // track has provided at least some frames recently: reset retry count
2920 track->mRetryCount = kMaxTrackRetries;
2921 }
2922 if (recentUnderruns == 0) {
2923 // no recent underruns: stay active
2924 break;
2925 }
2926 // there has recently been an underrun of some kind
2927 if (track->sharedBuffer() == 0) {
2928 // were any of the recent underruns "empty" (no frames available)?
2929 if (recentEmpty == 0) {
2930 // no, then ignore the partial underruns as they are allowed indefinitely
2931 break;
2932 }
2933 // there has recently been an "empty" underrun: decrement the retry counter
2934 if (--(track->mRetryCount) > 0) {
2935 break;
2936 }
2937 // indicate to client process that the track was disabled because of underrun;
2938 // it will then automatically call start() when data is available
2939 android_atomic_or(CBLK_DISABLED_ON, &track->mCblk->flags);
2940 // remove from active list, but state remains ACTIVE [confusing but true]
2941 isActive = false;
Glenn Kastend08f48c2012-05-01 18:14:02 -07002942 break;
2943 }
2944 // fall through
2945 case TrackBase::STOPPING_2:
2946 case TrackBase::PAUSED:
2947 case TrackBase::TERMINATED:
Eric Laurent29864602012-05-08 18:57:51 -07002948 case TrackBase::STOPPED:
2949 case TrackBase::FLUSHED: // flush() while active
Glenn Kastend08f48c2012-05-01 18:14:02 -07002950 // Check for presentation complete if track is inactive
2951 // We have consumed all the buffers of this track.
2952 // This would be incomplete if we auto-paused on underrun
2953 {
2954 size_t audioHALFrames =
2955 (mOutput->stream->get_latency(mOutput->stream)*mSampleRate) / 1000;
2956 size_t framesWritten =
2957 mBytesWritten / audio_stream_frame_size(&mOutput->stream->common);
2958 if (!track->presentationComplete(framesWritten, audioHALFrames)) {
2959 // track stays in active list until presentation is complete
2960 break;
2961 }
2962 }
2963 if (track->isStopping_2()) {
2964 track->mState = TrackBase::STOPPED;
2965 }
2966 if (track->isStopped()) {
2967 // Can't reset directly, as fast mixer is still polling this track
2968 // track->reset();
2969 // So instead mark this track as needing to be reset after push with ack
2970 resetMask |= 1 << i;
2971 }
2972 isActive = false;
2973 break;
2974 case TrackBase::IDLE:
2975 default:
2976 LOG_FATAL("unexpected track state %d", track->mState);
Glenn Kasten288ed212012-04-25 17:52:27 -07002977 }
2978
2979 if (isActive) {
2980 // was it previously inactive?
2981 if (!(state->mTrackMask & (1 << j))) {
2982 ExtendedAudioBufferProvider *eabp = track;
2983 VolumeProvider *vp = track;
2984 fastTrack->mBufferProvider = eabp;
2985 fastTrack->mVolumeProvider = vp;
2986 fastTrack->mSampleRate = track->mSampleRate;
2987 fastTrack->mChannelMask = track->mChannelMask;
2988 fastTrack->mGeneration++;
2989 state->mTrackMask |= 1 << j;
2990 didModify = true;
2991 // no acknowledgement required for newly active tracks
2992 }
2993 // cache the combined master volume and stream type volume for fast mixer; this
2994 // lacks any synchronization or barrier so VolumeProvider may read a stale value
2995 track->mCachedVolume = track->isMuted() ?
2996 0 : masterVolume * mStreamTypes[track->streamType()].volume;
2997 ++fastTracks;
2998 } else {
2999 // was it previously active?
3000 if (state->mTrackMask & (1 << j)) {
3001 fastTrack->mBufferProvider = NULL;
3002 fastTrack->mGeneration++;
3003 state->mTrackMask &= ~(1 << j);
3004 didModify = true;
3005 // If any fast tracks were removed, we must wait for acknowledgement
3006 // because we're about to decrement the last sp<> on those tracks.
3007 block = FastMixerStateQueue::BLOCK_UNTIL_ACKED;
Glenn Kastend08f48c2012-05-01 18:14:02 -07003008 } else {
3009 LOG_FATAL("fast track %d should have been active", j);
Glenn Kasten288ed212012-04-25 17:52:27 -07003010 }
Glenn Kastend08f48c2012-05-01 18:14:02 -07003011 tracksToRemove->add(track);
Glenn Kasten288ed212012-04-25 17:52:27 -07003012 // Avoids a misleading display in dumpsys
Glenn Kasten09474df2012-05-10 14:48:07 -07003013 track->mObservedUnderruns.mBitFields.mMostRecent = UNDERRUN_FULL;
Glenn Kasten58912562012-04-03 10:45:00 -07003014 }
3015 continue;
3016 }
3017
3018 { // local variable scope to avoid goto warning
3019
Mathias Agopian65ab4712010-07-14 17:59:35 -07003020 audio_track_cblk_t* cblk = track->cblk();
3021
3022 // The first time a track is added we wait
3023 // for all its buffers to be filled before processing it
Glenn Kasten9c56d4a2011-12-19 15:06:39 -08003024 int name = track->name();
Eric Laurenta47b69c2011-11-08 18:10:16 -08003025 // make sure that we have enough frames to mix one full buffer.
3026 // enforce this condition only once to enable draining the buffer in case the client
3027 // app does not call stop() and relies on underrun to stop:
Eric Laurentda747442012-04-25 18:53:13 -07003028 // hence the test on (mMixerStatus == MIXER_TRACKS_READY) meaning the track was mixed
Eric Laurenta47b69c2011-11-08 18:10:16 -08003029 // during last round
Eric Laurent3dbe3202011-11-03 12:16:05 -07003030 uint32_t minFrames = 1;
Eric Laurent83faee02012-04-27 18:24:29 -07003031 if ((track->sharedBuffer() == 0) && !track->isStopped() && !track->isPausing() &&
Glenn Kasten81028042012-04-30 18:15:12 -07003032 (mMixerStatusIgnoringFastTracks == MIXER_TRACKS_READY)) {
Eric Laurent3dbe3202011-11-03 12:16:05 -07003033 if (t->sampleRate() == (int)mSampleRate) {
Glenn Kasten58912562012-04-03 10:45:00 -07003034 minFrames = mNormalFrameCount;
Eric Laurent3dbe3202011-11-03 12:16:05 -07003035 } else {
Eric Laurent071ccd52011-12-22 16:08:41 -08003036 // +1 for rounding and +1 for additional sample needed for interpolation
Glenn Kasten58912562012-04-03 10:45:00 -07003037 minFrames = (mNormalFrameCount * t->sampleRate()) / mSampleRate + 1 + 1;
Eric Laurent071ccd52011-12-22 16:08:41 -08003038 // add frames already consumed but not yet released by the resampler
Glenn Kastenea7939a2012-03-14 12:56:26 -07003039 // because cblk->framesReady() will include these frames
Eric Laurent071ccd52011-12-22 16:08:41 -08003040 minFrames += mAudioMixer->getUnreleasedFrames(track->name());
3041 // the minimum track buffer size is normally twice the number of frames necessary
3042 // to fill one buffer and the resampler should not leave more than one buffer worth
3043 // of unreleased frames after each pass, but just in case...
Steve Blockc1dc1cb2012-01-09 18:35:44 +00003044 ALOG_ASSERT(minFrames <= cblk->frameCount);
Eric Laurent3dbe3202011-11-03 12:16:05 -07003045 }
3046 }
John Grossman4ff14ba2012-02-08 16:37:41 -08003047 if ((track->framesReady() >= minFrames) && track->isReady() &&
Mathias Agopian65ab4712010-07-14 17:59:35 -07003048 !track->isPaused() && !track->isTerminated())
3049 {
Glenn Kasten9c56d4a2011-12-19 15:06:39 -08003050 //ALOGV("track %d u=%08x, s=%08x [OK] on thread %p", name, cblk->user, cblk->server, this);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003051
3052 mixedTracks++;
3053
3054 // track->mainBuffer() != mMixBuffer means there is an effect chain
3055 // connected to the track
3056 chain.clear();
3057 if (track->mainBuffer() != mMixBuffer) {
3058 chain = getEffectChain_l(track->sessionId());
3059 // Delegate volume control to effect in track effect chain if needed
3060 if (chain != 0) {
3061 tracksWithEffect++;
3062 } else {
Steve Block5ff1dd52012-01-05 23:22:43 +00003063 ALOGW("prepareTracks_l(): track %d attached to effect but no chain found on session %d",
Glenn Kasten9c56d4a2011-12-19 15:06:39 -08003064 name, track->sessionId());
Mathias Agopian65ab4712010-07-14 17:59:35 -07003065 }
3066 }
3067
3068
3069 int param = AudioMixer::VOLUME;
3070 if (track->mFillingUpStatus == Track::FS_FILLED) {
3071 // no ramp for the first volume setting
3072 track->mFillingUpStatus = Track::FS_ACTIVE;
3073 if (track->mState == TrackBase::RESUMING) {
3074 track->mState = TrackBase::ACTIVE;
3075 param = AudioMixer::RAMP_VOLUME;
3076 }
Glenn Kasten9c56d4a2011-12-19 15:06:39 -08003077 mAudioMixer->setParameter(name, AudioMixer::RESAMPLE, AudioMixer::RESET, NULL);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003078 } else if (cblk->server != 0) {
3079 // If the track is stopped before the first frame was mixed,
3080 // do not apply ramp
3081 param = AudioMixer::RAMP_VOLUME;
3082 }
3083
3084 // compute volume for this track
Eric Laurente0aed6d2010-09-10 17:44:44 -07003085 uint32_t vl, vr, va;
Eric Laurent8569f0d2010-07-29 23:43:43 -07003086 if (track->isMuted() || track->isPausing() ||
Glenn Kasten02bbd202012-02-08 12:35:35 -08003087 mStreamTypes[track->streamType()].mute) {
Eric Laurente0aed6d2010-09-10 17:44:44 -07003088 vl = vr = va = 0;
Mathias Agopian65ab4712010-07-14 17:59:35 -07003089 if (track->isPausing()) {
3090 track->setPaused();
3091 }
3092 } else {
Eric Laurente0aed6d2010-09-10 17:44:44 -07003093
Mathias Agopian65ab4712010-07-14 17:59:35 -07003094 // read original volumes with volume control
Glenn Kasten02bbd202012-02-08 12:35:35 -08003095 float typeVolume = mStreamTypes[track->streamType()].volume;
Mathias Agopian65ab4712010-07-14 17:59:35 -07003096 float v = masterVolume * typeVolume;
Glenn Kasten83d86532012-01-17 14:39:34 -08003097 uint32_t vlr = cblk->getVolumeLR();
Glenn Kastenb1cf75c2012-01-17 12:20:54 -08003098 vl = vlr & 0xFFFF;
3099 vr = vlr >> 16;
3100 // track volumes come from shared memory, so can't be trusted and must be clamped
3101 if (vl > MAX_GAIN_INT) {
3102 ALOGV("Track left volume out of range: %04X", vl);
3103 vl = MAX_GAIN_INT;
3104 }
3105 if (vr > MAX_GAIN_INT) {
3106 ALOGV("Track right volume out of range: %04X", vr);
3107 vr = MAX_GAIN_INT;
3108 }
3109 // now apply the master volume and stream type volume
3110 vl = (uint32_t)(v * vl) << 12;
3111 vr = (uint32_t)(v * vr) << 12;
3112 // assuming master volume and stream type volume each go up to 1.0,
3113 // vl and vr are now in 8.24 format
Mathias Agopian65ab4712010-07-14 17:59:35 -07003114
Glenn Kasten05632a52012-01-03 14:22:33 -08003115 uint16_t sendLevel = cblk->getSendLevel_U4_12();
3116 // send level comes from shared memory and so may be corrupt
Glenn Kasten3b81aca2012-01-27 15:26:23 -08003117 if (sendLevel > MAX_GAIN_INT) {
Glenn Kasten05632a52012-01-03 14:22:33 -08003118 ALOGV("Track send level out of range: %04X", sendLevel);
Glenn Kastenb1cf75c2012-01-17 12:20:54 -08003119 sendLevel = MAX_GAIN_INT;
Glenn Kasten05632a52012-01-03 14:22:33 -08003120 }
3121 va = (uint32_t)(v * sendLevel);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003122 }
Eric Laurente0aed6d2010-09-10 17:44:44 -07003123 // Delegate volume control to effect in track effect chain if needed
3124 if (chain != 0 && chain->setVolume_l(&vl, &vr)) {
3125 // Do not ramp volume if volume is controlled by effect
3126 param = AudioMixer::VOLUME;
3127 track->mHasVolumeController = true;
3128 } else {
3129 // force no volume ramp when volume controller was just disabled or removed
3130 // from effect chain to avoid volume spike
3131 if (track->mHasVolumeController) {
3132 param = AudioMixer::VOLUME;
3133 }
3134 track->mHasVolumeController = false;
3135 }
3136
3137 // Convert volumes from 8.24 to 4.12 format
Glenn Kastenb1cf75c2012-01-17 12:20:54 -08003138 // This additional clamping is needed in case chain->setVolume_l() overshot
Glenn Kasten3b81aca2012-01-27 15:26:23 -08003139 vl = (vl + (1 << 11)) >> 12;
3140 if (vl > MAX_GAIN_INT) vl = MAX_GAIN_INT;
3141 vr = (vr + (1 << 11)) >> 12;
3142 if (vr > MAX_GAIN_INT) vr = MAX_GAIN_INT;
Eric Laurente0aed6d2010-09-10 17:44:44 -07003143
Glenn Kasten3b81aca2012-01-27 15:26:23 -08003144 if (va > MAX_GAIN_INT) va = MAX_GAIN_INT; // va is uint32_t, so no need to check for -
Mathias Agopian65ab4712010-07-14 17:59:35 -07003145
Mathias Agopian65ab4712010-07-14 17:59:35 -07003146 // XXX: these things DON'T need to be done each time
Glenn Kasten9c56d4a2011-12-19 15:06:39 -08003147 mAudioMixer->setBufferProvider(name, track);
3148 mAudioMixer->enable(name);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003149
Glenn Kasten3b81aca2012-01-27 15:26:23 -08003150 mAudioMixer->setParameter(name, param, AudioMixer::VOLUME0, (void *)vl);
3151 mAudioMixer->setParameter(name, param, AudioMixer::VOLUME1, (void *)vr);
3152 mAudioMixer->setParameter(name, param, AudioMixer::AUXLEVEL, (void *)va);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003153 mAudioMixer->setParameter(
Glenn Kasten9c56d4a2011-12-19 15:06:39 -08003154 name,
Mathias Agopian65ab4712010-07-14 17:59:35 -07003155 AudioMixer::TRACK,
3156 AudioMixer::FORMAT, (void *)track->format());
3157 mAudioMixer->setParameter(
Glenn Kasten9c56d4a2011-12-19 15:06:39 -08003158 name,
Mathias Agopian65ab4712010-07-14 17:59:35 -07003159 AudioMixer::TRACK,
Jean-Michel Trivi0d255b22011-05-24 15:53:33 -07003160 AudioMixer::CHANNEL_MASK, (void *)track->channelMask());
Mathias Agopian65ab4712010-07-14 17:59:35 -07003161 mAudioMixer->setParameter(
Glenn Kasten9c56d4a2011-12-19 15:06:39 -08003162 name,
Mathias Agopian65ab4712010-07-14 17:59:35 -07003163 AudioMixer::RESAMPLE,
3164 AudioMixer::SAMPLE_RATE,
3165 (void *)(cblk->sampleRate));
3166 mAudioMixer->setParameter(
Glenn Kasten9c56d4a2011-12-19 15:06:39 -08003167 name,
Mathias Agopian65ab4712010-07-14 17:59:35 -07003168 AudioMixer::TRACK,
3169 AudioMixer::MAIN_BUFFER, (void *)track->mainBuffer());
3170 mAudioMixer->setParameter(
Glenn Kasten9c56d4a2011-12-19 15:06:39 -08003171 name,
Mathias Agopian65ab4712010-07-14 17:59:35 -07003172 AudioMixer::TRACK,
3173 AudioMixer::AUX_BUFFER, (void *)track->auxBuffer());
3174
3175 // reset retry count
3176 track->mRetryCount = kMaxTrackRetries;
Glenn Kastenea7939a2012-03-14 12:56:26 -07003177
Eric Laurent27741442012-01-17 19:20:12 -08003178 // If one track is ready, set the mixer ready if:
3179 // - the mixer was not ready during previous round OR
3180 // - no other track is not ready
Glenn Kasten81028042012-04-30 18:15:12 -07003181 if (mMixerStatusIgnoringFastTracks != MIXER_TRACKS_READY ||
Eric Laurent27741442012-01-17 19:20:12 -08003182 mixerStatus != MIXER_TRACKS_ENABLED) {
3183 mixerStatus = MIXER_TRACKS_READY;
3184 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07003185 } else {
Eric Laurent91b14c42012-05-30 12:30:29 -07003186 // clear effect chain input buffer if an active track underruns to avoid sending
3187 // previous audio buffer again to effects
3188 chain = getEffectChain_l(track->sessionId());
3189 if (chain != 0) {
3190 chain->clearInputBuffer();
3191 }
3192
Glenn Kasten9c56d4a2011-12-19 15:06:39 -08003193 //ALOGV("track %d u=%08x, s=%08x [NOT READY] on thread %p", name, cblk->user, cblk->server, this);
Eric Laurent83faee02012-04-27 18:24:29 -07003194 if ((track->sharedBuffer() != 0) || track->isTerminated() ||
3195 track->isStopped() || track->isPaused()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07003196 // We have consumed all the buffers of this track.
3197 // Remove it from the list of active tracks.
Eric Laurenta011e352012-03-29 15:51:43 -07003198 // TODO: use actual buffer filling status instead of latency when available from
3199 // audio HAL
3200 size_t audioHALFrames =
3201 (mOutput->stream->get_latency(mOutput->stream)*mSampleRate) / 1000;
3202 size_t framesWritten =
3203 mBytesWritten / audio_stream_frame_size(&mOutput->stream->common);
3204 if (track->presentationComplete(framesWritten, audioHALFrames)) {
Eric Laurent29864602012-05-08 18:57:51 -07003205 if (track->isStopped()) {
3206 track->reset();
3207 }
Eric Laurenta011e352012-03-29 15:51:43 -07003208 tracksToRemove->add(track);
3209 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07003210 } else {
Glenn Kastenbf0d21f2012-05-31 14:59:29 -07003211 track->mUnderrunCount++;
Mathias Agopian65ab4712010-07-14 17:59:35 -07003212 // No buffers for this track. Give it a few chances to
3213 // fill a buffer, then remove it from active list.
3214 if (--(track->mRetryCount) <= 0) {
Glenn Kasten9c56d4a2011-12-19 15:06:39 -08003215 ALOGV("BUFFER TIMEOUT: remove(%d) from active list on thread %p", name, this);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003216 tracksToRemove->add(track);
Glenn Kasten288ed212012-04-25 17:52:27 -07003217 // indicate to client process that the track was disabled because of underrun;
3218 // it will then automatically call start() when data is available
Eric Laurent38ccae22011-03-28 18:37:07 -07003219 android_atomic_or(CBLK_DISABLED_ON, &cblk->flags);
Eric Laurent27741442012-01-17 19:20:12 -08003220 // If one track is not ready, mark the mixer also not ready if:
3221 // - the mixer was ready during previous round OR
3222 // - no other track is ready
Glenn Kasten81028042012-04-30 18:15:12 -07003223 } else if (mMixerStatusIgnoringFastTracks == MIXER_TRACKS_READY ||
Eric Laurent27741442012-01-17 19:20:12 -08003224 mixerStatus != MIXER_TRACKS_READY) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07003225 mixerStatus = MIXER_TRACKS_ENABLED;
3226 }
3227 }
Glenn Kasten9c56d4a2011-12-19 15:06:39 -08003228 mAudioMixer->disable(name);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003229 }
Glenn Kasten58912562012-04-03 10:45:00 -07003230
3231 } // local variable scope to avoid goto warning
3232track_is_ready: ;
3233
Mathias Agopian65ab4712010-07-14 17:59:35 -07003234 }
3235
Glenn Kasten288ed212012-04-25 17:52:27 -07003236 // Push the new FastMixer state if necessary
3237 if (didModify) {
3238 state->mFastTracksGen++;
3239 // if the fast mixer was active, but now there are no fast tracks, then put it in cold idle
3240 if (kUseFastMixer == FastMixer_Dynamic &&
3241 state->mCommand == FastMixerState::MIX_WRITE && state->mTrackMask <= 1) {
3242 state->mCommand = FastMixerState::COLD_IDLE;
3243 state->mColdFutexAddr = &mFastMixerFutex;
3244 state->mColdGen++;
3245 mFastMixerFutex = 0;
3246 if (kUseFastMixer == FastMixer_Dynamic) {
3247 mNormalSink = mOutputSink;
3248 }
3249 // If we go into cold idle, need to wait for acknowledgement
3250 // so that fast mixer stops doing I/O.
3251 block = FastMixerStateQueue::BLOCK_UNTIL_ACKED;
3252 }
3253 sq->end();
3254 }
3255 if (sq != NULL) {
3256 sq->end(didModify);
3257 sq->push(block);
3258 }
3259
3260 // Now perform the deferred reset on fast tracks that have stopped
3261 while (resetMask != 0) {
3262 size_t i = __builtin_ctz(resetMask);
3263 ALOG_ASSERT(i < count);
3264 resetMask &= ~(1 << i);
3265 sp<Track> t = mActiveTracks[i].promote();
3266 if (t == 0) continue;
3267 Track* track = t.get();
3268 ALOG_ASSERT(track->isFastTrack() && track->isStopped());
3269 track->reset();
3270 }
Glenn Kasten58912562012-04-03 10:45:00 -07003271
Mathias Agopian65ab4712010-07-14 17:59:35 -07003272 // remove all the tracks that need to be...
3273 count = tracksToRemove->size();
Glenn Kastenf6b16782011-12-15 09:51:17 -08003274 if (CC_UNLIKELY(count)) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07003275 for (size_t i=0 ; i<count ; i++) {
3276 const sp<Track>& track = tracksToRemove->itemAt(i);
3277 mActiveTracks.remove(track);
3278 if (track->mainBuffer() != mMixBuffer) {
3279 chain = getEffectChain_l(track->sessionId());
3280 if (chain != 0) {
Steve Block3856b092011-10-20 11:56:00 +01003281 ALOGV("stopping track on chain %p for session Id: %d", chain.get(), track->sessionId());
Eric Laurentb469b942011-05-09 12:09:06 -07003282 chain->decActiveTrackCnt();
Mathias Agopian65ab4712010-07-14 17:59:35 -07003283 }
3284 }
3285 if (track->isTerminated()) {
Eric Laurentb469b942011-05-09 12:09:06 -07003286 removeTrack_l(track);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003287 }
3288 }
3289 }
3290
3291 // mix buffer must be cleared if all tracks are connected to an
3292 // effect chain as in this case the mixer will not write to
3293 // mix buffer and track effects will accumulate into it
Glenn Kasten58912562012-04-03 10:45:00 -07003294 if ((mixedTracks != 0 && mixedTracks == tracksWithEffect) || (mixedTracks == 0 && fastTracks > 0)) {
3295 // FIXME as a performance optimization, should remember previous zero status
3296 memset(mMixBuffer, 0, mNormalFrameCount * mChannelCount * sizeof(int16_t));
Mathias Agopian65ab4712010-07-14 17:59:35 -07003297 }
3298
Glenn Kasten58912562012-04-03 10:45:00 -07003299 // if any fast tracks, then status is ready
Glenn Kasten81028042012-04-30 18:15:12 -07003300 mMixerStatusIgnoringFastTracks = mixerStatus;
Glenn Kasten58912562012-04-03 10:45:00 -07003301 if (fastTracks > 0) {
3302 mixerStatus = MIXER_TRACKS_READY;
3303 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07003304 return mixerStatus;
3305}
3306
Glenn Kasten66fcab92012-02-24 14:59:21 -08003307/*
3308The derived values that are cached:
3309 - mixBufferSize from frame count * frame size
3310 - activeSleepTime from activeSleepTimeUs()
3311 - idleSleepTime from idleSleepTimeUs()
3312 - standbyDelay from mActiveSleepTimeUs (DIRECT only)
3313 - maxPeriod from frame count and sample rate (MIXER only)
3314
3315The parameters that affect these derived values are:
3316 - frame count
3317 - frame size
3318 - sample rate
3319 - device type: A2DP or not
3320 - device latency
3321 - format: PCM or not
3322 - active sleep time
3323 - idle sleep time
3324*/
3325
3326void AudioFlinger::PlaybackThread::cacheParameters_l()
3327{
Glenn Kasten58912562012-04-03 10:45:00 -07003328 mixBufferSize = mNormalFrameCount * mFrameSize;
Glenn Kasten66fcab92012-02-24 14:59:21 -08003329 activeSleepTime = activeSleepTimeUs();
3330 idleSleepTime = idleSleepTimeUs();
3331}
3332
Glenn Kastenfff6d712012-01-12 16:38:12 -08003333void AudioFlinger::MixerThread::invalidateTracks(audio_stream_type_t streamType)
Mathias Agopian65ab4712010-07-14 17:59:35 -07003334{
Steve Block3856b092011-10-20 11:56:00 +01003335 ALOGV ("MixerThread::invalidateTracks() mixer %p, streamType %d, mTracks.size %d",
Eric Laurentde070132010-07-13 04:45:46 -07003336 this, streamType, mTracks.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07003337 Mutex::Autolock _l(mLock);
Eric Laurentde070132010-07-13 04:45:46 -07003338
Mathias Agopian65ab4712010-07-14 17:59:35 -07003339 size_t size = mTracks.size();
3340 for (size_t i = 0; i < size; i++) {
3341 sp<Track> t = mTracks[i];
Glenn Kasten02bbd202012-02-08 12:35:35 -08003342 if (t->streamType() == streamType) {
Eric Laurent38ccae22011-03-28 18:37:07 -07003343 android_atomic_or(CBLK_INVALID_ON, &t->mCblk->flags);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003344 t->mCblk->cv.signal();
Mathias Agopian65ab4712010-07-14 17:59:35 -07003345 }
3346 }
3347}
3348
Mathias Agopian65ab4712010-07-14 17:59:35 -07003349// getTrackName_l() must be called with ThreadBase::mLock held
Jean-Michel Trivi7d5b2622012-04-04 18:54:36 -07003350int AudioFlinger::MixerThread::getTrackName_l(audio_channel_mask_t channelMask)
Mathias Agopian65ab4712010-07-14 17:59:35 -07003351{
Jean-Michel Trivi9bd23222012-04-16 13:43:48 -07003352 return mAudioMixer->getTrackName(channelMask);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003353}
3354
3355// deleteTrackName_l() must be called with ThreadBase::mLock held
3356void AudioFlinger::MixerThread::deleteTrackName_l(int name)
3357{
Steve Block3856b092011-10-20 11:56:00 +01003358 ALOGV("remove track (%d) and delete from mixer", name);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003359 mAudioMixer->deleteTrackName(name);
3360}
3361
3362// checkForNewParameters_l() must be called with ThreadBase::mLock held
3363bool AudioFlinger::MixerThread::checkForNewParameters_l()
3364{
Glenn Kasten58912562012-04-03 10:45:00 -07003365 // if !&IDLE, holds the FastMixer state to restore after new parameters processed
3366 FastMixerState::Command previousCommand = FastMixerState::HOT_IDLE;
Mathias Agopian65ab4712010-07-14 17:59:35 -07003367 bool reconfig = false;
3368
3369 while (!mNewParameters.isEmpty()) {
Glenn Kasten58912562012-04-03 10:45:00 -07003370
3371 if (mFastMixer != NULL) {
3372 FastMixerStateQueue *sq = mFastMixer->sq();
3373 FastMixerState *state = sq->begin();
3374 if (!(state->mCommand & FastMixerState::IDLE)) {
3375 previousCommand = state->mCommand;
3376 state->mCommand = FastMixerState::HOT_IDLE;
3377 sq->end();
3378 sq->push(FastMixerStateQueue::BLOCK_UNTIL_ACKED);
3379 } else {
3380 sq->end(false /*didModify*/);
3381 }
3382 }
3383
Mathias Agopian65ab4712010-07-14 17:59:35 -07003384 status_t status = NO_ERROR;
3385 String8 keyValuePair = mNewParameters[0];
3386 AudioParameter param = AudioParameter(keyValuePair);
3387 int value;
3388
3389 if (param.getInt(String8(AudioParameter::keySamplingRate), value) == NO_ERROR) {
3390 reconfig = true;
3391 }
3392 if (param.getInt(String8(AudioParameter::keyFormat), value) == NO_ERROR) {
Glenn Kasten58f30212012-01-12 12:27:51 -08003393 if ((audio_format_t) value != AUDIO_FORMAT_PCM_16_BIT) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07003394 status = BAD_VALUE;
3395 } else {
3396 reconfig = true;
3397 }
3398 }
3399 if (param.getInt(String8(AudioParameter::keyChannels), value) == NO_ERROR) {
Dima Zavinfce7a472011-04-19 22:30:36 -07003400 if (value != AUDIO_CHANNEL_OUT_STEREO) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07003401 status = BAD_VALUE;
3402 } else {
3403 reconfig = true;
3404 }
3405 }
3406 if (param.getInt(String8(AudioParameter::keyFrameCount), value) == NO_ERROR) {
3407 // do not accept frame count changes if tracks are open as the track buffer
Glenn Kasten362c4e62011-12-14 10:28:06 -08003408 // size depends on frame count and correct behavior would not be guaranteed
Mathias Agopian65ab4712010-07-14 17:59:35 -07003409 // if frame count is changed after track creation
3410 if (!mTracks.isEmpty()) {
3411 status = INVALID_OPERATION;
3412 } else {
3413 reconfig = true;
3414 }
3415 }
3416 if (param.getInt(String8(AudioParameter::keyRouting), value) == NO_ERROR) {
Glenn Kastend3cee2f2012-03-13 17:55:35 -07003417#ifdef ADD_BATTERY_DATA
Gloria Wang9ee159b2011-02-24 14:51:45 -08003418 // when changing the audio output device, call addBatteryData to notify
3419 // the change
Eric Laurentb469b942011-05-09 12:09:06 -07003420 if ((int)mDevice != value) {
Gloria Wang9ee159b2011-02-24 14:51:45 -08003421 uint32_t params = 0;
3422 // check whether speaker is on
Dima Zavinfce7a472011-04-19 22:30:36 -07003423 if (value & AUDIO_DEVICE_OUT_SPEAKER) {
Gloria Wang9ee159b2011-02-24 14:51:45 -08003424 params |= IMediaPlayerService::kBatteryDataSpeakerOn;
3425 }
3426
3427 int deviceWithoutSpeaker
Dima Zavinfce7a472011-04-19 22:30:36 -07003428 = AUDIO_DEVICE_OUT_ALL & ~AUDIO_DEVICE_OUT_SPEAKER;
Gloria Wang9ee159b2011-02-24 14:51:45 -08003429 // check if any other device (except speaker) is on
3430 if (value & deviceWithoutSpeaker ) {
3431 params |= IMediaPlayerService::kBatteryDataOtherAudioDeviceOn;
3432 }
3433
3434 if (params != 0) {
3435 addBatteryData(params);
3436 }
3437 }
Glenn Kastend3cee2f2012-03-13 17:55:35 -07003438#endif
Gloria Wang9ee159b2011-02-24 14:51:45 -08003439
Mathias Agopian65ab4712010-07-14 17:59:35 -07003440 // forward device change to effects that have requested to be
3441 // aware of attached audio device.
3442 mDevice = (uint32_t)value;
3443 for (size_t i = 0; i < mEffectChains.size(); i++) {
Eric Laurentcab11242010-07-15 12:50:15 -07003444 mEffectChains[i]->setDevice_l(mDevice);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003445 }
3446 }
3447
3448 if (status == NO_ERROR) {
Dima Zavin799a70e2011-04-18 16:57:27 -07003449 status = mOutput->stream->common.set_parameters(&mOutput->stream->common,
Dima Zavinfce7a472011-04-19 22:30:36 -07003450 keyValuePair.string());
Mathias Agopian65ab4712010-07-14 17:59:35 -07003451 if (!mStandby && status == INVALID_OPERATION) {
Glenn Kastene53b9ea2012-03-12 16:29:55 -07003452 mOutput->stream->common.standby(&mOutput->stream->common);
3453 mStandby = true;
3454 mBytesWritten = 0;
3455 status = mOutput->stream->common.set_parameters(&mOutput->stream->common,
Dima Zavinfce7a472011-04-19 22:30:36 -07003456 keyValuePair.string());
Mathias Agopian65ab4712010-07-14 17:59:35 -07003457 }
3458 if (status == NO_ERROR && reconfig) {
3459 delete mAudioMixer;
Glenn Kastene9dd0172012-01-27 18:08:45 -08003460 // for safety in case readOutputParameters() accesses mAudioMixer (it doesn't)
3461 mAudioMixer = NULL;
Mathias Agopian65ab4712010-07-14 17:59:35 -07003462 readOutputParameters();
Glenn Kasten58912562012-04-03 10:45:00 -07003463 mAudioMixer = new AudioMixer(mNormalFrameCount, mSampleRate);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003464 for (size_t i = 0; i < mTracks.size() ; i++) {
Jean-Michel Trivi7d5b2622012-04-04 18:54:36 -07003465 int name = getTrackName_l((audio_channel_mask_t)mTracks[i]->mChannelMask);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003466 if (name < 0) break;
3467 mTracks[i]->mName = name;
3468 // limit track sample rate to 2 x new output sample rate
3469 if (mTracks[i]->mCblk->sampleRate > 2 * sampleRate()) {
3470 mTracks[i]->mCblk->sampleRate = 2 * sampleRate();
3471 }
3472 }
3473 sendConfigEvent_l(AudioSystem::OUTPUT_CONFIG_CHANGED);
3474 }
3475 }
3476
3477 mNewParameters.removeAt(0);
3478
3479 mParamStatus = status;
3480 mParamCond.signal();
Eric Laurent60cd0a02011-09-13 11:40:21 -07003481 // wait for condition with time out in case the thread calling ThreadBase::setParameters()
3482 // already timed out waiting for the status and will never signal the condition.
Glenn Kasten7dede872011-12-13 11:04:14 -08003483 mWaitWorkCV.waitRelative(mLock, kSetParametersTimeoutNs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003484 }
Glenn Kasten58912562012-04-03 10:45:00 -07003485
3486 if (!(previousCommand & FastMixerState::IDLE)) {
3487 ALOG_ASSERT(mFastMixer != NULL);
3488 FastMixerStateQueue *sq = mFastMixer->sq();
3489 FastMixerState *state = sq->begin();
3490 ALOG_ASSERT(state->mCommand == FastMixerState::HOT_IDLE);
3491 state->mCommand = previousCommand;
3492 sq->end();
3493 sq->push(FastMixerStateQueue::BLOCK_UNTIL_PUSHED);
3494 }
3495
Mathias Agopian65ab4712010-07-14 17:59:35 -07003496 return reconfig;
3497}
3498
3499status_t AudioFlinger::MixerThread::dumpInternals(int fd, const Vector<String16>& args)
3500{
3501 const size_t SIZE = 256;
3502 char buffer[SIZE];
3503 String8 result;
3504
3505 PlaybackThread::dumpInternals(fd, args);
3506
3507 snprintf(buffer, SIZE, "AudioMixer tracks: %08x\n", mAudioMixer->trackNames());
3508 result.append(buffer);
3509 write(fd, result.string(), result.size());
Glenn Kasten58912562012-04-03 10:45:00 -07003510
3511 // Make a non-atomic copy of fast mixer dump state so it won't change underneath us
3512 FastMixerDumpState copy = mFastMixerDumpState;
3513 copy.dump(fd);
3514
Glenn Kasten39993082012-05-31 13:40:27 -07003515#ifdef STATE_QUEUE_DUMP
3516 // Similar for state queue
3517 StateQueueObserverDump observerCopy = mStateQueueObserverDump;
3518 observerCopy.dump(fd);
3519 StateQueueMutatorDump mutatorCopy = mStateQueueMutatorDump;
3520 mutatorCopy.dump(fd);
3521#endif
3522
Glenn Kastenfbae5da2012-05-21 09:17:20 -07003523 // Write the tee output to a .wav file
3524 NBAIO_Source *teeSource = mTeeSource.get();
3525 if (teeSource != NULL) {
3526 char teePath[64];
3527 struct timeval tv;
3528 gettimeofday(&tv, NULL);
3529 struct tm tm;
3530 localtime_r(&tv.tv_sec, &tm);
3531 strftime(teePath, sizeof(teePath), "/data/misc/media/%T.wav", &tm);
3532 int teeFd = open(teePath, O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR);
3533 if (teeFd >= 0) {
3534 char wavHeader[44];
3535 memcpy(wavHeader,
3536 "RIFF\0\0\0\0WAVEfmt \20\0\0\0\1\0\2\0\104\254\0\0\0\0\0\0\4\0\20\0data\0\0\0\0",
3537 sizeof(wavHeader));
3538 NBAIO_Format format = teeSource->format();
3539 unsigned channelCount = Format_channelCount(format);
3540 ALOG_ASSERT(channelCount <= FCC_2);
3541 unsigned sampleRate = Format_sampleRate(format);
3542 wavHeader[22] = channelCount; // number of channels
3543 wavHeader[24] = sampleRate; // sample rate
3544 wavHeader[25] = sampleRate >> 8;
3545 wavHeader[32] = channelCount * 2; // block alignment
3546 write(teeFd, wavHeader, sizeof(wavHeader));
3547 size_t total = 0;
3548 bool firstRead = true;
3549 for (;;) {
3550#define TEE_SINK_READ 1024
3551 short buffer[TEE_SINK_READ * FCC_2];
3552 size_t count = TEE_SINK_READ;
3553 ssize_t actual = teeSource->read(buffer, count);
3554 bool wasFirstRead = firstRead;
3555 firstRead = false;
3556 if (actual <= 0) {
3557 if (actual == (ssize_t) OVERRUN && wasFirstRead) {
3558 continue;
3559 }
3560 break;
3561 }
3562 ALOG_ASSERT(actual <= count);
3563 write(teeFd, buffer, actual * channelCount * sizeof(short));
3564 total += actual;
3565 }
3566 lseek(teeFd, (off_t) 4, SEEK_SET);
3567 uint32_t temp = 44 + total * channelCount * sizeof(short) - 8;
3568 write(teeFd, &temp, sizeof(temp));
3569 lseek(teeFd, (off_t) 40, SEEK_SET);
3570 temp = total * channelCount * sizeof(short);
3571 write(teeFd, &temp, sizeof(temp));
3572 close(teeFd);
3573 fdprintf(fd, "FastMixer tee copied to %s\n", teePath);
3574 } else {
3575 fdprintf(fd, "FastMixer unable to create tee %s: \n", strerror(errno));
3576 }
3577 }
3578
Mathias Agopian65ab4712010-07-14 17:59:35 -07003579 return NO_ERROR;
3580}
3581
Glenn Kasten0bf65bd2012-02-28 18:32:53 -08003582uint32_t AudioFlinger::MixerThread::idleSleepTimeUs() const
Mathias Agopian65ab4712010-07-14 17:59:35 -07003583{
Glenn Kasten58912562012-04-03 10:45:00 -07003584 return (uint32_t)(((mNormalFrameCount * 1000) / mSampleRate) * 1000) / 2;
Mathias Agopian65ab4712010-07-14 17:59:35 -07003585}
3586
Glenn Kasten0bf65bd2012-02-28 18:32:53 -08003587uint32_t AudioFlinger::MixerThread::suspendSleepTimeUs() const
Eric Laurent25cbe0e2010-08-18 18:13:17 -07003588{
Glenn Kasten58912562012-04-03 10:45:00 -07003589 return (uint32_t)(((mNormalFrameCount * 1000) / mSampleRate) * 1000);
Eric Laurent25cbe0e2010-08-18 18:13:17 -07003590}
3591
Glenn Kasten66fcab92012-02-24 14:59:21 -08003592void AudioFlinger::MixerThread::cacheParameters_l()
3593{
3594 PlaybackThread::cacheParameters_l();
3595
3596 // FIXME: Relaxed timing because of a certain device that can't meet latency
3597 // Should be reduced to 2x after the vendor fixes the driver issue
3598 // increase threshold again due to low power audio mode. The way this warning
3599 // threshold is calculated and its usefulness should be reconsidered anyway.
Glenn Kasten58912562012-04-03 10:45:00 -07003600 maxPeriod = seconds(mNormalFrameCount) / mSampleRate * 15;
Glenn Kasten66fcab92012-02-24 14:59:21 -08003601}
3602
Mathias Agopian65ab4712010-07-14 17:59:35 -07003603// ----------------------------------------------------------------------------
Glenn Kasten72ef00d2012-01-17 11:09:42 -08003604AudioFlinger::DirectOutputThread::DirectOutputThread(const sp<AudioFlinger>& audioFlinger,
3605 AudioStreamOut* output, audio_io_handle_t id, uint32_t device)
Glenn Kasten23bb8be2012-01-26 10:38:26 -08003606 : PlaybackThread(audioFlinger, output, id, device, DIRECT)
Glenn Kasten84afa3b2012-01-25 15:28:08 -08003607 // mLeftVolFloat, mRightVolFloat
Mathias Agopian65ab4712010-07-14 17:59:35 -07003608{
Mathias Agopian65ab4712010-07-14 17:59:35 -07003609}
3610
3611AudioFlinger::DirectOutputThread::~DirectOutputThread()
3612{
3613}
3614
Glenn Kasten1465f0c2012-03-06 11:23:32 -08003615AudioFlinger::PlaybackThread::mixer_state AudioFlinger::DirectOutputThread::prepareTracks_l(
3616 Vector< sp<Track> > *tracksToRemove
Glenn Kasten000f0e32012-03-01 17:10:56 -08003617)
Mathias Agopian65ab4712010-07-14 17:59:35 -07003618{
Glenn Kasten1465f0c2012-03-06 11:23:32 -08003619 sp<Track> trackToRemove;
3620
Glenn Kastenfec279f2012-03-08 07:47:15 -08003621 mixer_state mixerStatus = MIXER_IDLE;
Mathias Agopian65ab4712010-07-14 17:59:35 -07003622
Glenn Kasten952eeb22012-03-06 11:30:57 -08003623 // find out which tracks need to be processed
3624 if (mActiveTracks.size() != 0) {
3625 sp<Track> t = mActiveTracks[0].promote();
Glenn Kastenfec279f2012-03-08 07:47:15 -08003626 // The track died recently
3627 if (t == 0) return MIXER_IDLE;
Mathias Agopian65ab4712010-07-14 17:59:35 -07003628
Glenn Kasten952eeb22012-03-06 11:30:57 -08003629 Track* const track = t.get();
3630 audio_track_cblk_t* cblk = track->cblk();
Mathias Agopian65ab4712010-07-14 17:59:35 -07003631
Glenn Kasten952eeb22012-03-06 11:30:57 -08003632 // The first time a track is added we wait
3633 // for all its buffers to be filled before processing it
Eric Laurent67c0a582012-05-01 19:31:12 -07003634 uint32_t minFrames;
3635 if ((track->sharedBuffer() == 0) && !track->isStopped() && !track->isPausing()) {
3636 minFrames = mNormalFrameCount;
3637 } else {
3638 minFrames = 1;
3639 }
3640 if ((track->framesReady() >= minFrames) && track->isReady() &&
Glenn Kasten952eeb22012-03-06 11:30:57 -08003641 !track->isPaused() && !track->isTerminated())
3642 {
3643 //ALOGV("track %d u=%08x, s=%08x [OK]", track->name(), cblk->user, cblk->server);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003644
Glenn Kasten952eeb22012-03-06 11:30:57 -08003645 if (track->mFillingUpStatus == Track::FS_FILLED) {
3646 track->mFillingUpStatus = Track::FS_ACTIVE;
3647 mLeftVolFloat = mRightVolFloat = 0;
Glenn Kasten952eeb22012-03-06 11:30:57 -08003648 if (track->mState == TrackBase::RESUMING) {
3649 track->mState = TrackBase::ACTIVE;
Glenn Kasten952eeb22012-03-06 11:30:57 -08003650 }
Glenn Kasten952eeb22012-03-06 11:30:57 -08003651 }
Eric Laurent67c0a582012-05-01 19:31:12 -07003652
Glenn Kasten952eeb22012-03-06 11:30:57 -08003653 // compute volume for this track
3654 float left, right;
3655 if (track->isMuted() || mMasterMute || track->isPausing() ||
3656 mStreamTypes[track->streamType()].mute) {
3657 left = right = 0;
3658 if (track->isPausing()) {
3659 track->setPaused();
3660 }
3661 } else {
3662 float typeVolume = mStreamTypes[track->streamType()].volume;
3663 float v = mMasterVolume * typeVolume;
3664 uint32_t vlr = cblk->getVolumeLR();
3665 float v_clamped = v * (vlr & 0xFFFF);
3666 if (v_clamped > MAX_GAIN) v_clamped = MAX_GAIN;
3667 left = v_clamped/MAX_GAIN;
3668 v_clamped = v * (vlr >> 16);
3669 if (v_clamped > MAX_GAIN) v_clamped = MAX_GAIN;
3670 right = v_clamped/MAX_GAIN;
3671 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07003672
Glenn Kasten952eeb22012-03-06 11:30:57 -08003673 if (left != mLeftVolFloat || right != mRightVolFloat) {
3674 mLeftVolFloat = left;
3675 mRightVolFloat = right;
Mathias Agopian65ab4712010-07-14 17:59:35 -07003676
Glenn Kasten952eeb22012-03-06 11:30:57 -08003677 // Convert volumes from float to 8.24
3678 uint32_t vl = (uint32_t)(left * (1 << 24));
3679 uint32_t vr = (uint32_t)(right * (1 << 24));
Mathias Agopian65ab4712010-07-14 17:59:35 -07003680
Glenn Kasten952eeb22012-03-06 11:30:57 -08003681 // Delegate volume control to effect in track effect chain if needed
3682 // only one effect chain can be present on DirectOutputThread, so if
3683 // there is one, the track is connected to it
3684 if (!mEffectChains.isEmpty()) {
3685 // Do not ramp volume if volume is controlled by effect
Eric Laurent67c0a582012-05-01 19:31:12 -07003686 mEffectChains[0]->setVolume_l(&vl, &vr);
3687 left = (float)vl / (1 << 24);
3688 right = (float)vr / (1 << 24);
Glenn Kasten952eeb22012-03-06 11:30:57 -08003689 }
Eric Laurent67c0a582012-05-01 19:31:12 -07003690 mOutput->stream->set_volume(mOutput->stream, left, right);
Glenn Kasten952eeb22012-03-06 11:30:57 -08003691 }
3692
3693 // reset retry count
3694 track->mRetryCount = kMaxTrackRetriesDirect;
Glenn Kastenb071e9b2012-03-07 17:05:59 -08003695 mActiveTrack = t;
Glenn Kastenfec279f2012-03-08 07:47:15 -08003696 mixerStatus = MIXER_TRACKS_READY;
Glenn Kasten952eeb22012-03-06 11:30:57 -08003697 } else {
Eric Laurent91b14c42012-05-30 12:30:29 -07003698 // clear effect chain input buffer if an active track underruns to avoid sending
3699 // previous audio buffer again to effects
3700 if (!mEffectChains.isEmpty()) {
3701 mEffectChains[0]->clearInputBuffer();
3702 }
3703
Glenn Kasten952eeb22012-03-06 11:30:57 -08003704 //ALOGV("track %d u=%08x, s=%08x [NOT READY]", track->name(), cblk->user, cblk->server);
Eric Laurent67c0a582012-05-01 19:31:12 -07003705 if ((track->sharedBuffer() != 0) || track->isTerminated() ||
3706 track->isStopped() || track->isPaused()) {
Glenn Kasten952eeb22012-03-06 11:30:57 -08003707 // We have consumed all the buffers of this track.
3708 // Remove it from the list of active tracks.
Eric Laurenta011e352012-03-29 15:51:43 -07003709 // TODO: implement behavior for compressed audio
3710 size_t audioHALFrames =
3711 (mOutput->stream->get_latency(mOutput->stream)*mSampleRate) / 1000;
3712 size_t framesWritten =
3713 mBytesWritten / audio_stream_frame_size(&mOutput->stream->common);
3714 if (track->presentationComplete(framesWritten, audioHALFrames)) {
Eric Laurent29864602012-05-08 18:57:51 -07003715 if (track->isStopped()) {
3716 track->reset();
3717 }
Eric Laurenta011e352012-03-29 15:51:43 -07003718 trackToRemove = track;
3719 }
Glenn Kasten952eeb22012-03-06 11:30:57 -08003720 } else {
3721 // No buffers for this track. Give it a few chances to
3722 // fill a buffer, then remove it from active list.
3723 if (--(track->mRetryCount) <= 0) {
3724 ALOGV("BUFFER TIMEOUT: remove(%d) from active list", track->name());
3725 trackToRemove = track;
Mathias Agopian65ab4712010-07-14 17:59:35 -07003726 } else {
Glenn Kastenfec279f2012-03-08 07:47:15 -08003727 mixerStatus = MIXER_TRACKS_ENABLED;
Mathias Agopian65ab4712010-07-14 17:59:35 -07003728 }
3729 }
Glenn Kasten952eeb22012-03-06 11:30:57 -08003730 }
3731 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07003732
Glenn Kasten1465f0c2012-03-06 11:23:32 -08003733 // FIXME merge this with similar code for removing multiple tracks
Glenn Kasten952eeb22012-03-06 11:30:57 -08003734 // remove all the tracks that need to be...
3735 if (CC_UNLIKELY(trackToRemove != 0)) {
Glenn Kasten1465f0c2012-03-06 11:23:32 -08003736 tracksToRemove->add(trackToRemove);
Glenn Kasten952eeb22012-03-06 11:30:57 -08003737 mActiveTracks.remove(trackToRemove);
3738 if (!mEffectChains.isEmpty()) {
Glenn Kasten5798d4e2012-03-08 12:18:35 -08003739 ALOGV("stopping track on chain %p for session Id: %d", mEffectChains[0].get(),
Glenn Kasten952eeb22012-03-06 11:30:57 -08003740 trackToRemove->sessionId());
3741 mEffectChains[0]->decActiveTrackCnt();
3742 }
3743 if (trackToRemove->isTerminated()) {
3744 removeTrack_l(trackToRemove);
3745 }
3746 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07003747
Glenn Kastenfec279f2012-03-08 07:47:15 -08003748 return mixerStatus;
Glenn Kasten000f0e32012-03-01 17:10:56 -08003749}
Mathias Agopian65ab4712010-07-14 17:59:35 -07003750
Glenn Kasten000f0e32012-03-01 17:10:56 -08003751void AudioFlinger::DirectOutputThread::threadLoop_mix()
3752{
Glenn Kasten952eeb22012-03-06 11:30:57 -08003753 AudioBufferProvider::Buffer buffer;
3754 size_t frameCount = mFrameCount;
3755 int8_t *curBuf = (int8_t *)mMixBuffer;
3756 // output audio to hardware
3757 while (frameCount) {
3758 buffer.frameCount = frameCount;
Glenn Kastenb071e9b2012-03-07 17:05:59 -08003759 mActiveTrack->getNextBuffer(&buffer);
Glenn Kasten952eeb22012-03-06 11:30:57 -08003760 if (CC_UNLIKELY(buffer.raw == NULL)) {
3761 memset(curBuf, 0, frameCount * mFrameSize);
3762 break;
3763 }
3764 memcpy(curBuf, buffer.raw, buffer.frameCount * mFrameSize);
3765 frameCount -= buffer.frameCount;
3766 curBuf += buffer.frameCount * mFrameSize;
Glenn Kastenb071e9b2012-03-07 17:05:59 -08003767 mActiveTrack->releaseBuffer(&buffer);
Glenn Kasten952eeb22012-03-06 11:30:57 -08003768 }
3769 sleepTime = 0;
3770 standbyTime = systemTime() + standbyDelay;
Glenn Kastenb071e9b2012-03-07 17:05:59 -08003771 mActiveTrack.clear();
Glenn Kasten73f4bc32012-03-09 12:08:48 -08003772
Glenn Kasten000f0e32012-03-01 17:10:56 -08003773}
3774
3775void AudioFlinger::DirectOutputThread::threadLoop_sleepTime()
3776{
Glenn Kasten952eeb22012-03-06 11:30:57 -08003777 if (sleepTime == 0) {
Glenn Kastenfec279f2012-03-08 07:47:15 -08003778 if (mMixerStatus == MIXER_TRACKS_ENABLED) {
Glenn Kasten952eeb22012-03-06 11:30:57 -08003779 sleepTime = activeSleepTime;
3780 } else {
3781 sleepTime = idleSleepTime;
3782 }
3783 } else if (mBytesWritten != 0 && audio_is_linear_pcm(mFormat)) {
Glenn Kasten58912562012-04-03 10:45:00 -07003784 memset(mMixBuffer, 0, mFrameCount * mFrameSize);
Glenn Kasten952eeb22012-03-06 11:30:57 -08003785 sleepTime = 0;
3786 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07003787}
3788
3789// getTrackName_l() must be called with ThreadBase::mLock held
Jean-Michel Trivi7d5b2622012-04-04 18:54:36 -07003790int AudioFlinger::DirectOutputThread::getTrackName_l(audio_channel_mask_t channelMask)
Mathias Agopian65ab4712010-07-14 17:59:35 -07003791{
3792 return 0;
3793}
3794
3795// deleteTrackName_l() must be called with ThreadBase::mLock held
3796void AudioFlinger::DirectOutputThread::deleteTrackName_l(int name)
3797{
3798}
3799
3800// checkForNewParameters_l() must be called with ThreadBase::mLock held
3801bool AudioFlinger::DirectOutputThread::checkForNewParameters_l()
3802{
3803 bool reconfig = false;
3804
3805 while (!mNewParameters.isEmpty()) {
3806 status_t status = NO_ERROR;
3807 String8 keyValuePair = mNewParameters[0];
3808 AudioParameter param = AudioParameter(keyValuePair);
3809 int value;
3810
3811 if (param.getInt(String8(AudioParameter::keyFrameCount), value) == NO_ERROR) {
3812 // do not accept frame count changes if tracks are open as the track buffer
3813 // size depends on frame count and correct behavior would not be garantied
3814 // if frame count is changed after track creation
3815 if (!mTracks.isEmpty()) {
3816 status = INVALID_OPERATION;
3817 } else {
3818 reconfig = true;
3819 }
3820 }
3821 if (status == NO_ERROR) {
Dima Zavin799a70e2011-04-18 16:57:27 -07003822 status = mOutput->stream->common.set_parameters(&mOutput->stream->common,
Dima Zavinfce7a472011-04-19 22:30:36 -07003823 keyValuePair.string());
Mathias Agopian65ab4712010-07-14 17:59:35 -07003824 if (!mStandby && status == INVALID_OPERATION) {
Glenn Kastene53b9ea2012-03-12 16:29:55 -07003825 mOutput->stream->common.standby(&mOutput->stream->common);
3826 mStandby = true;
3827 mBytesWritten = 0;
3828 status = mOutput->stream->common.set_parameters(&mOutput->stream->common,
Dima Zavinfce7a472011-04-19 22:30:36 -07003829 keyValuePair.string());
Mathias Agopian65ab4712010-07-14 17:59:35 -07003830 }
3831 if (status == NO_ERROR && reconfig) {
3832 readOutputParameters();
3833 sendConfigEvent_l(AudioSystem::OUTPUT_CONFIG_CHANGED);
3834 }
3835 }
3836
3837 mNewParameters.removeAt(0);
3838
3839 mParamStatus = status;
3840 mParamCond.signal();
Eric Laurent60cd0a02011-09-13 11:40:21 -07003841 // wait for condition with time out in case the thread calling ThreadBase::setParameters()
3842 // already timed out waiting for the status and will never signal the condition.
Glenn Kasten7dede872011-12-13 11:04:14 -08003843 mWaitWorkCV.waitRelative(mLock, kSetParametersTimeoutNs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003844 }
3845 return reconfig;
3846}
3847
Glenn Kasten0bf65bd2012-02-28 18:32:53 -08003848uint32_t AudioFlinger::DirectOutputThread::activeSleepTimeUs() const
Mathias Agopian65ab4712010-07-14 17:59:35 -07003849{
3850 uint32_t time;
Dima Zavinfce7a472011-04-19 22:30:36 -07003851 if (audio_is_linear_pcm(mFormat)) {
Eric Laurent162b40b2011-12-05 09:47:19 -08003852 time = PlaybackThread::activeSleepTimeUs();
Mathias Agopian65ab4712010-07-14 17:59:35 -07003853 } else {
3854 time = 10000;
3855 }
3856 return time;
3857}
3858
Glenn Kasten0bf65bd2012-02-28 18:32:53 -08003859uint32_t AudioFlinger::DirectOutputThread::idleSleepTimeUs() const
Mathias Agopian65ab4712010-07-14 17:59:35 -07003860{
3861 uint32_t time;
Dima Zavinfce7a472011-04-19 22:30:36 -07003862 if (audio_is_linear_pcm(mFormat)) {
Eric Laurent60e18242010-07-29 06:50:24 -07003863 time = (uint32_t)(((mFrameCount * 1000) / mSampleRate) * 1000) / 2;
Mathias Agopian65ab4712010-07-14 17:59:35 -07003864 } else {
3865 time = 10000;
3866 }
3867 return time;
3868}
3869
Glenn Kasten0bf65bd2012-02-28 18:32:53 -08003870uint32_t AudioFlinger::DirectOutputThread::suspendSleepTimeUs() const
Eric Laurent25cbe0e2010-08-18 18:13:17 -07003871{
3872 uint32_t time;
Dima Zavinfce7a472011-04-19 22:30:36 -07003873 if (audio_is_linear_pcm(mFormat)) {
Eric Laurent25cbe0e2010-08-18 18:13:17 -07003874 time = (uint32_t)(((mFrameCount * 1000) / mSampleRate) * 1000);
3875 } else {
3876 time = 10000;
3877 }
3878 return time;
3879}
3880
Glenn Kasten66fcab92012-02-24 14:59:21 -08003881void AudioFlinger::DirectOutputThread::cacheParameters_l()
3882{
3883 PlaybackThread::cacheParameters_l();
3884
3885 // use shorter standby delay as on normal output to release
3886 // hardware resources as soon as possible
3887 standbyDelay = microseconds(activeSleepTime*2);
3888}
Eric Laurent25cbe0e2010-08-18 18:13:17 -07003889
Mathias Agopian65ab4712010-07-14 17:59:35 -07003890// ----------------------------------------------------------------------------
3891
Glenn Kasten23bb8be2012-01-26 10:38:26 -08003892AudioFlinger::DuplicatingThread::DuplicatingThread(const sp<AudioFlinger>& audioFlinger,
Glenn Kasten72ef00d2012-01-17 11:09:42 -08003893 AudioFlinger::MixerThread* mainThread, audio_io_handle_t id)
Glenn Kasten23bb8be2012-01-26 10:38:26 -08003894 : MixerThread(audioFlinger, mainThread->getOutput(), id, mainThread->device(), DUPLICATING),
3895 mWaitTimeMs(UINT_MAX)
Mathias Agopian65ab4712010-07-14 17:59:35 -07003896{
Mathias Agopian65ab4712010-07-14 17:59:35 -07003897 addOutputTrack(mainThread);
3898}
3899
3900AudioFlinger::DuplicatingThread::~DuplicatingThread()
3901{
3902 for (size_t i = 0; i < mOutputTracks.size(); i++) {
3903 mOutputTracks[i]->destroy();
3904 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07003905}
3906
Glenn Kasten000f0e32012-03-01 17:10:56 -08003907void AudioFlinger::DuplicatingThread::threadLoop_mix()
Mathias Agopian65ab4712010-07-14 17:59:35 -07003908{
Glenn Kasten952eeb22012-03-06 11:30:57 -08003909 // mix buffers...
3910 if (outputsReady(outputTracks)) {
3911 mAudioMixer->process(AudioBufferProvider::kInvalidPTS);
3912 } else {
3913 memset(mMixBuffer, 0, mixBufferSize);
3914 }
3915 sleepTime = 0;
Glenn Kasten58912562012-04-03 10:45:00 -07003916 writeFrames = mNormalFrameCount;
Eric Laurenta4f7e0e2012-06-07 17:16:09 -07003917 standbyTime = systemTime() + standbyDelay;
Glenn Kasten000f0e32012-03-01 17:10:56 -08003918}
3919
3920void AudioFlinger::DuplicatingThread::threadLoop_sleepTime()
3921{
Glenn Kasten952eeb22012-03-06 11:30:57 -08003922 if (sleepTime == 0) {
Glenn Kastenfec279f2012-03-08 07:47:15 -08003923 if (mMixerStatus == MIXER_TRACKS_ENABLED) {
Glenn Kasten952eeb22012-03-06 11:30:57 -08003924 sleepTime = activeSleepTime;
3925 } else {
3926 sleepTime = idleSleepTime;
3927 }
3928 } else if (mBytesWritten != 0) {
Eric Laurenta4f7e0e2012-06-07 17:16:09 -07003929 if (mMixerStatus == MIXER_TRACKS_ENABLED) {
3930 writeFrames = mNormalFrameCount;
3931 memset(mMixBuffer, 0, mixBufferSize);
3932 } else {
3933 // flush remaining overflow buffers in output tracks
3934 writeFrames = 0;
Glenn Kasten952eeb22012-03-06 11:30:57 -08003935 }
Eric Laurenta4f7e0e2012-06-07 17:16:09 -07003936 sleepTime = 0;
Glenn Kasten952eeb22012-03-06 11:30:57 -08003937 }
Glenn Kasten000f0e32012-03-01 17:10:56 -08003938}
Mathias Agopian65ab4712010-07-14 17:59:35 -07003939
Glenn Kasten000f0e32012-03-01 17:10:56 -08003940void AudioFlinger::DuplicatingThread::threadLoop_write()
3941{
Glenn Kasten952eeb22012-03-06 11:30:57 -08003942 for (size_t i = 0; i < outputTracks.size(); i++) {
3943 outputTracks[i]->write(mMixBuffer, writeFrames);
3944 }
3945 mBytesWritten += mixBufferSize;
Glenn Kasten000f0e32012-03-01 17:10:56 -08003946}
Glenn Kasten688a6402012-02-29 07:57:06 -08003947
Glenn Kasten000f0e32012-03-01 17:10:56 -08003948void AudioFlinger::DuplicatingThread::threadLoop_standby()
3949{
Glenn Kasten952eeb22012-03-06 11:30:57 -08003950 // DuplicatingThread implements standby by stopping all tracks
3951 for (size_t i = 0; i < outputTracks.size(); i++) {
3952 outputTracks[i]->stop();
3953 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07003954}
3955
Glenn Kastenfa26a852012-03-06 11:28:04 -08003956void AudioFlinger::DuplicatingThread::saveOutputTracks()
3957{
3958 outputTracks = mOutputTracks;
3959}
3960
3961void AudioFlinger::DuplicatingThread::clearOutputTracks()
3962{
3963 outputTracks.clear();
3964}
3965
Mathias Agopian65ab4712010-07-14 17:59:35 -07003966void AudioFlinger::DuplicatingThread::addOutputTrack(MixerThread *thread)
3967{
Glenn Kastenb6b74062012-02-24 14:12:20 -08003968 Mutex::Autolock _l(mLock);
Glenn Kasten99e53b82012-01-19 08:59:58 -08003969 // FIXME explain this formula
Glenn Kasten58912562012-04-03 10:45:00 -07003970 int frameCount = (3 * mNormalFrameCount * mSampleRate) / thread->sampleRate();
Glenn Kasten9eaa5572012-01-20 13:32:16 -08003971 OutputTrack *outputTrack = new OutputTrack(thread,
Mathias Agopian65ab4712010-07-14 17:59:35 -07003972 this,
3973 mSampleRate,
3974 mFormat,
Jean-Michel Trivi0d255b22011-05-24 15:53:33 -07003975 mChannelMask,
Mathias Agopian65ab4712010-07-14 17:59:35 -07003976 frameCount);
3977 if (outputTrack->cblk() != NULL) {
Dima Zavinfce7a472011-04-19 22:30:36 -07003978 thread->setStreamVolume(AUDIO_STREAM_CNT, 1.0f);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003979 mOutputTracks.add(outputTrack);
Steve Block3856b092011-10-20 11:56:00 +01003980 ALOGV("addOutputTrack() track %p, on thread %p", outputTrack, thread);
Glenn Kasten438b0362012-03-06 11:24:48 -08003981 updateWaitTime_l();
Mathias Agopian65ab4712010-07-14 17:59:35 -07003982 }
3983}
3984
3985void AudioFlinger::DuplicatingThread::removeOutputTrack(MixerThread *thread)
3986{
3987 Mutex::Autolock _l(mLock);
3988 for (size_t i = 0; i < mOutputTracks.size(); i++) {
Glenn Kastena1117922012-01-26 10:53:32 -08003989 if (mOutputTracks[i]->thread() == thread) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07003990 mOutputTracks[i]->destroy();
3991 mOutputTracks.removeAt(i);
Glenn Kasten438b0362012-03-06 11:24:48 -08003992 updateWaitTime_l();
Mathias Agopian65ab4712010-07-14 17:59:35 -07003993 return;
3994 }
3995 }
Steve Block3856b092011-10-20 11:56:00 +01003996 ALOGV("removeOutputTrack(): unkonwn thread: %p", thread);
Mathias Agopian65ab4712010-07-14 17:59:35 -07003997}
3998
Glenn Kasten438b0362012-03-06 11:24:48 -08003999// caller must hold mLock
4000void AudioFlinger::DuplicatingThread::updateWaitTime_l()
Mathias Agopian65ab4712010-07-14 17:59:35 -07004001{
4002 mWaitTimeMs = UINT_MAX;
4003 for (size_t i = 0; i < mOutputTracks.size(); i++) {
4004 sp<ThreadBase> strong = mOutputTracks[i]->thread().promote();
Glenn Kasten7378ca52012-01-20 13:44:40 -08004005 if (strong != 0) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07004006 uint32_t waitTimeMs = (strong->frameCount() * 2 * 1000) / strong->sampleRate();
4007 if (waitTimeMs < mWaitTimeMs) {
4008 mWaitTimeMs = waitTimeMs;
4009 }
4010 }
4011 }
4012}
4013
4014
Glenn Kasten02fe1bf2012-02-24 15:42:17 -08004015bool AudioFlinger::DuplicatingThread::outputsReady(const SortedVector< sp<OutputTrack> > &outputTracks)
Mathias Agopian65ab4712010-07-14 17:59:35 -07004016{
4017 for (size_t i = 0; i < outputTracks.size(); i++) {
Glenn Kastene53b9ea2012-03-12 16:29:55 -07004018 sp<ThreadBase> thread = outputTracks[i]->thread().promote();
Mathias Agopian65ab4712010-07-14 17:59:35 -07004019 if (thread == 0) {
Steve Block5ff1dd52012-01-05 23:22:43 +00004020 ALOGW("DuplicatingThread::outputsReady() could not promote thread on output track %p", outputTracks[i].get());
Mathias Agopian65ab4712010-07-14 17:59:35 -07004021 return false;
4022 }
4023 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
4024 if (playbackThread->standby() && !playbackThread->isSuspended()) {
Steve Block3856b092011-10-20 11:56:00 +01004025 ALOGV("DuplicatingThread output track %p on thread %p Not Ready", outputTracks[i].get(), thread.get());
Mathias Agopian65ab4712010-07-14 17:59:35 -07004026 return false;
4027 }
4028 }
4029 return true;
4030}
4031
Glenn Kasten0bf65bd2012-02-28 18:32:53 -08004032uint32_t AudioFlinger::DuplicatingThread::activeSleepTimeUs() const
Mathias Agopian65ab4712010-07-14 17:59:35 -07004033{
4034 return (mWaitTimeMs * 1000) / 2;
4035}
4036
Glenn Kasten66fcab92012-02-24 14:59:21 -08004037void AudioFlinger::DuplicatingThread::cacheParameters_l()
4038{
4039 // updateWaitTime_l() sets mWaitTimeMs, which affects activeSleepTimeUs(), so call it first
4040 updateWaitTime_l();
4041
4042 MixerThread::cacheParameters_l();
4043}
4044
Mathias Agopian65ab4712010-07-14 17:59:35 -07004045// ----------------------------------------------------------------------------
4046
4047// TrackBase constructor must be called with AudioFlinger::mLock held
4048AudioFlinger::ThreadBase::TrackBase::TrackBase(
Glenn Kasten9eaa5572012-01-20 13:32:16 -08004049 ThreadBase *thread,
Mathias Agopian65ab4712010-07-14 17:59:35 -07004050 const sp<Client>& client,
4051 uint32_t sampleRate,
Glenn Kasten58f30212012-01-12 12:27:51 -08004052 audio_format_t format,
Jean-Michel Trivi0d255b22011-05-24 15:53:33 -07004053 uint32_t channelMask,
Mathias Agopian65ab4712010-07-14 17:59:35 -07004054 int frameCount,
Mathias Agopian65ab4712010-07-14 17:59:35 -07004055 const sp<IMemory>& sharedBuffer,
4056 int sessionId)
4057 : RefBase(),
4058 mThread(thread),
4059 mClient(client),
Glenn Kasten84afa3b2012-01-25 15:28:08 -08004060 mCblk(NULL),
4061 // mBuffer
4062 // mBufferEnd
Mathias Agopian65ab4712010-07-14 17:59:35 -07004063 mFrameCount(0),
4064 mState(IDLE),
Glenn Kasten58912562012-04-03 10:45:00 -07004065 mSampleRate(sampleRate),
Mathias Agopian65ab4712010-07-14 17:59:35 -07004066 mFormat(format),
Glenn Kasten5cf034d2012-02-21 10:35:56 -08004067 mStepServerFailed(false),
Mathias Agopian65ab4712010-07-14 17:59:35 -07004068 mSessionId(sessionId)
Glenn Kasten84afa3b2012-01-25 15:28:08 -08004069 // mChannelCount
4070 // mChannelMask
Mathias Agopian65ab4712010-07-14 17:59:35 -07004071{
Steve Block3856b092011-10-20 11:56:00 +01004072 ALOGV_IF(sharedBuffer != 0, "sharedBuffer: %p, size: %d", sharedBuffer->pointer(), sharedBuffer->size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07004073
Steve Blockb8a80522011-12-20 16:23:08 +00004074 // ALOGD("Creating track with %d buffers @ %d bytes", bufferCount, bufferSize);
Glenn Kastene53b9ea2012-03-12 16:29:55 -07004075 size_t size = sizeof(audio_track_cblk_t);
4076 uint8_t channelCount = popcount(channelMask);
4077 size_t bufferSize = frameCount*channelCount*sizeof(int16_t);
4078 if (sharedBuffer == 0) {
4079 size += bufferSize;
4080 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07004081
Glenn Kastene53b9ea2012-03-12 16:29:55 -07004082 if (client != NULL) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07004083 mCblkMemory = client->heap()->allocate(size);
4084 if (mCblkMemory != 0) {
4085 mCblk = static_cast<audio_track_cblk_t *>(mCblkMemory->pointer());
Glenn Kastena0d68332012-01-27 16:47:15 -08004086 if (mCblk != NULL) { // construct the shared structure in-place.
Mathias Agopian65ab4712010-07-14 17:59:35 -07004087 new(mCblk) audio_track_cblk_t();
4088 // clear all buffers
4089 mCblk->frameCount = frameCount;
4090 mCblk->sampleRate = sampleRate;
Marco Nelissena1472d92012-03-30 14:36:54 -07004091// uncomment the following lines to quickly test 32-bit wraparound
4092// mCblk->user = 0xffff0000;
4093// mCblk->server = 0xffff0000;
4094// mCblk->userBase = 0xffff0000;
4095// mCblk->serverBase = 0xffff0000;
Jean-Michel Trivi0d255b22011-05-24 15:53:33 -07004096 mChannelCount = channelCount;
4097 mChannelMask = channelMask;
Mathias Agopian65ab4712010-07-14 17:59:35 -07004098 if (sharedBuffer == 0) {
4099 mBuffer = (char*)mCblk + sizeof(audio_track_cblk_t);
4100 memset(mBuffer, 0, frameCount*channelCount*sizeof(int16_t));
4101 // Force underrun condition to avoid false underrun callback until first data is
Eric Laurent44d98482010-09-30 16:12:31 -07004102 // written to buffer (other flags are cleared)
Mathias Agopian65ab4712010-07-14 17:59:35 -07004103 mCblk->flags = CBLK_UNDERRUN_ON;
4104 } else {
4105 mBuffer = sharedBuffer->pointer();
4106 }
4107 mBufferEnd = (uint8_t *)mBuffer + bufferSize;
4108 }
4109 } else {
Steve Block29357bc2012-01-06 19:20:56 +00004110 ALOGE("not enough memory for AudioTrack size=%u", size);
Mathias Agopian65ab4712010-07-14 17:59:35 -07004111 client->heap()->dump("AudioTrack");
4112 return;
4113 }
Glenn Kastene53b9ea2012-03-12 16:29:55 -07004114 } else {
4115 mCblk = (audio_track_cblk_t *)(new uint8_t[size]);
Glenn Kastenea7939a2012-03-14 12:56:26 -07004116 // construct the shared structure in-place.
4117 new(mCblk) audio_track_cblk_t();
4118 // clear all buffers
4119 mCblk->frameCount = frameCount;
4120 mCblk->sampleRate = sampleRate;
Marco Nelissena1472d92012-03-30 14:36:54 -07004121// uncomment the following lines to quickly test 32-bit wraparound
4122// mCblk->user = 0xffff0000;
4123// mCblk->server = 0xffff0000;
4124// mCblk->userBase = 0xffff0000;
4125// mCblk->serverBase = 0xffff0000;
Glenn Kastenea7939a2012-03-14 12:56:26 -07004126 mChannelCount = channelCount;
4127 mChannelMask = channelMask;
4128 mBuffer = (char*)mCblk + sizeof(audio_track_cblk_t);
4129 memset(mBuffer, 0, frameCount*channelCount*sizeof(int16_t));
4130 // Force underrun condition to avoid false underrun callback until first data is
4131 // written to buffer (other flags are cleared)
4132 mCblk->flags = CBLK_UNDERRUN_ON;
4133 mBufferEnd = (uint8_t *)mBuffer + bufferSize;
Glenn Kastene53b9ea2012-03-12 16:29:55 -07004134 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07004135}
4136
4137AudioFlinger::ThreadBase::TrackBase::~TrackBase()
4138{
Glenn Kastena0d68332012-01-27 16:47:15 -08004139 if (mCblk != NULL) {
Glenn Kasten1a0ae5b2012-02-03 10:24:48 -08004140 if (mClient == 0) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07004141 delete mCblk;
Glenn Kasten1a0ae5b2012-02-03 10:24:48 -08004142 } else {
4143 mCblk->~audio_track_cblk_t(); // destroy our shared-structure.
Mathias Agopian65ab4712010-07-14 17:59:35 -07004144 }
4145 }
Glenn Kastendbfafaf2012-01-25 15:27:15 -08004146 mCblkMemory.clear(); // free the shared memory before releasing the heap it belongs to
Glenn Kasten7378ca52012-01-20 13:44:40 -08004147 if (mClient != 0) {
Glenn Kasten84afa3b2012-01-25 15:28:08 -08004148 // Client destructor must run with AudioFlinger mutex locked
Mathias Agopian65ab4712010-07-14 17:59:35 -07004149 Mutex::Autolock _l(mClient->audioFlinger()->mLock);
Glenn Kasten7378ca52012-01-20 13:44:40 -08004150 // If the client's reference count drops to zero, the associated destructor
4151 // must run with AudioFlinger lock held. Thus the explicit clear() rather than
4152 // relying on the automatic clear() at end of scope.
Mathias Agopian65ab4712010-07-14 17:59:35 -07004153 mClient.clear();
4154 }
4155}
4156
Glenn Kasten01c4ebf2012-02-22 10:47:35 -08004157// AudioBufferProvider interface
4158// getNextBuffer() = 0;
4159// This implementation of releaseBuffer() is used by Track and RecordTrack, but not TimedTrack
Mathias Agopian65ab4712010-07-14 17:59:35 -07004160void AudioFlinger::ThreadBase::TrackBase::releaseBuffer(AudioBufferProvider::Buffer* buffer)
4161{
Glenn Kastene0feee32011-12-13 11:53:26 -08004162 buffer->raw = NULL;
Mathias Agopian65ab4712010-07-14 17:59:35 -07004163 mFrameCount = buffer->frameCount;
Glenn Kasten288ed212012-04-25 17:52:27 -07004164 // FIXME See note at getNextBuffer()
Glenn Kasten01c4ebf2012-02-22 10:47:35 -08004165 (void) step(); // ignore return value of step()
Mathias Agopian65ab4712010-07-14 17:59:35 -07004166 buffer->frameCount = 0;
4167}
4168
4169bool AudioFlinger::ThreadBase::TrackBase::step() {
4170 bool result;
4171 audio_track_cblk_t* cblk = this->cblk();
4172
4173 result = cblk->stepServer(mFrameCount);
4174 if (!result) {
Steve Block3856b092011-10-20 11:56:00 +01004175 ALOGV("stepServer failed acquiring cblk mutex");
Glenn Kasten5cf034d2012-02-21 10:35:56 -08004176 mStepServerFailed = true;
Mathias Agopian65ab4712010-07-14 17:59:35 -07004177 }
4178 return result;
4179}
4180
4181void AudioFlinger::ThreadBase::TrackBase::reset() {
4182 audio_track_cblk_t* cblk = this->cblk();
4183
4184 cblk->user = 0;
4185 cblk->server = 0;
4186 cblk->userBase = 0;
4187 cblk->serverBase = 0;
Glenn Kasten5cf034d2012-02-21 10:35:56 -08004188 mStepServerFailed = false;
Steve Block3856b092011-10-20 11:56:00 +01004189 ALOGV("TrackBase::reset");
Mathias Agopian65ab4712010-07-14 17:59:35 -07004190}
4191
Mathias Agopian65ab4712010-07-14 17:59:35 -07004192int AudioFlinger::ThreadBase::TrackBase::sampleRate() const {
4193 return (int)mCblk->sampleRate;
4194}
4195
Mathias Agopian65ab4712010-07-14 17:59:35 -07004196void* AudioFlinger::ThreadBase::TrackBase::getBuffer(uint32_t offset, uint32_t frames) const {
4197 audio_track_cblk_t* cblk = this->cblk();
Glenn Kastenb9980652012-01-11 09:48:27 -08004198 size_t frameSize = cblk->frameSize;
4199 int8_t *bufferStart = (int8_t *)mBuffer + (offset-cblk->serverBase)*frameSize;
4200 int8_t *bufferEnd = bufferStart + frames * frameSize;
Mathias Agopian65ab4712010-07-14 17:59:35 -07004201
4202 // Check validity of returned pointer in case the track control block would have been corrupted.
Jean-Michel Triviacb86cc2012-04-16 12:43:57 -07004203 ALOG_ASSERT(!(bufferStart < mBuffer || bufferStart > bufferEnd || bufferEnd > mBufferEnd),
4204 "TrackBase::getBuffer buffer out of range:\n"
4205 " start: %p, end %p , mBuffer %p mBufferEnd %p\n"
4206 " server %u, serverBase %u, user %u, userBase %u, frameSize %d",
Mathias Agopian65ab4712010-07-14 17:59:35 -07004207 bufferStart, bufferEnd, mBuffer, mBufferEnd,
Jean-Michel Triviacb86cc2012-04-16 12:43:57 -07004208 cblk->server, cblk->serverBase, cblk->user, cblk->userBase, frameSize);
Mathias Agopian65ab4712010-07-14 17:59:35 -07004209
4210 return bufferStart;
4211}
4212
Eric Laurenta011e352012-03-29 15:51:43 -07004213status_t AudioFlinger::ThreadBase::TrackBase::setSyncEvent(const sp<SyncEvent>& event)
4214{
4215 mSyncEvents.add(event);
4216 return NO_ERROR;
4217}
4218
Mathias Agopian65ab4712010-07-14 17:59:35 -07004219// ----------------------------------------------------------------------------
4220
4221// Track constructor must be called with AudioFlinger::mLock and ThreadBase::mLock held
4222AudioFlinger::PlaybackThread::Track::Track(
Glenn Kasten9eaa5572012-01-20 13:32:16 -08004223 PlaybackThread *thread,
Mathias Agopian65ab4712010-07-14 17:59:35 -07004224 const sp<Client>& client,
Glenn Kastenfff6d712012-01-12 16:38:12 -08004225 audio_stream_type_t streamType,
Mathias Agopian65ab4712010-07-14 17:59:35 -07004226 uint32_t sampleRate,
Glenn Kasten58f30212012-01-12 12:27:51 -08004227 audio_format_t format,
Jean-Michel Trivi0d255b22011-05-24 15:53:33 -07004228 uint32_t channelMask,
Mathias Agopian65ab4712010-07-14 17:59:35 -07004229 int frameCount,
4230 const sp<IMemory>& sharedBuffer,
Glenn Kasten73d22752012-03-19 13:38:30 -07004231 int sessionId,
4232 IAudioFlinger::track_flags_t flags)
Glenn Kasten5cf034d2012-02-21 10:35:56 -08004233 : TrackBase(thread, client, sampleRate, format, channelMask, frameCount, sharedBuffer, sessionId),
Glenn Kastenf9959012012-03-19 11:14:37 -07004234 mMute(false),
Glenn Kasten58912562012-04-03 10:45:00 -07004235 mFillingUpStatus(FS_INVALID),
Glenn Kastenf9959012012-03-19 11:14:37 -07004236 // mRetryCount initialized later when needed
4237 mSharedBuffer(sharedBuffer),
4238 mStreamType(streamType),
4239 mName(-1), // see note below
4240 mMainBuffer(thread->mixBuffer()),
4241 mAuxBuffer(NULL),
Eric Laurenta011e352012-03-29 15:51:43 -07004242 mAuxEffectId(0), mHasVolumeController(false),
Glenn Kasten73d22752012-03-19 13:38:30 -07004243 mPresentationCompleteFrames(0),
Glenn Kasten58912562012-04-03 10:45:00 -07004244 mFlags(flags),
4245 mFastIndex(-1),
Glenn Kasten288ed212012-04-25 17:52:27 -07004246 mUnderrunCount(0),
Glenn Kasten58912562012-04-03 10:45:00 -07004247 mCachedVolume(1.0)
Mathias Agopian65ab4712010-07-14 17:59:35 -07004248{
4249 if (mCblk != NULL) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07004250 // NOTE: audio_track_cblk_t::frameSize for 8 bit PCM data is based on a sample size of
4251 // 16 bit because data is converted to 16 bit before being stored in buffer by AudioTrack
Eric Laurentedc15ad2011-07-21 19:35:01 -07004252 mCblk->frameSize = audio_is_linear_pcm(format) ? mChannelCount * sizeof(int16_t) : sizeof(uint8_t);
Glenn Kasten893a0542012-05-30 10:32:06 -07004253 // to avoid leaking a track name, do not allocate one unless there is an mCblk
4254 mName = thread->getTrackName_l((audio_channel_mask_t)channelMask);
4255 if (mName < 0) {
4256 ALOGE("no more track names available");
4257 return;
4258 }
4259 // only allocate a fast track index if we were able to allocate a normal track name
Glenn Kasten58912562012-04-03 10:45:00 -07004260 if (flags & IAudioFlinger::TRACK_FAST) {
4261 mCblk->flags |= CBLK_FAST; // atomic op not needed yet
4262 ALOG_ASSERT(thread->mFastTrackAvailMask != 0);
4263 int i = __builtin_ctz(thread->mFastTrackAvailMask);
Eric Laurent29864602012-05-08 18:57:51 -07004264 ALOG_ASSERT(0 < i && i < (int)FastMixerState::kMaxFastTracks);
Glenn Kasten288ed212012-04-25 17:52:27 -07004265 // FIXME This is too eager. We allocate a fast track index before the
4266 // fast track becomes active. Since fast tracks are a scarce resource,
4267 // this means we are potentially denying other more important fast tracks from
4268 // being created. It would be better to allocate the index dynamically.
Glenn Kasten58912562012-04-03 10:45:00 -07004269 mFastIndex = i;
Glenn Kasten288ed212012-04-25 17:52:27 -07004270 // Read the initial underruns because this field is never cleared by the fast mixer
Glenn Kasten09474df2012-05-10 14:48:07 -07004271 mObservedUnderruns = thread->getFastTrackUnderruns(i);
Glenn Kasten58912562012-04-03 10:45:00 -07004272 thread->mFastTrackAvailMask &= ~(1 << i);
Glenn Kasten58912562012-04-03 10:45:00 -07004273 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07004274 }
Glenn Kastenf9959012012-03-19 11:14:37 -07004275 ALOGV("Track constructor name %d, calling pid %d", mName, IPCThreadState::self()->getCallingPid());
Mathias Agopian65ab4712010-07-14 17:59:35 -07004276}
4277
4278AudioFlinger::PlaybackThread::Track::~Track()
4279{
Steve Block3856b092011-10-20 11:56:00 +01004280 ALOGV("PlaybackThread::Track destructor");
Mathias Agopian65ab4712010-07-14 17:59:35 -07004281 sp<ThreadBase> thread = mThread.promote();
4282 if (thread != 0) {
4283 Mutex::Autolock _l(thread->mLock);
4284 mState = TERMINATED;
4285 }
4286}
4287
4288void AudioFlinger::PlaybackThread::Track::destroy()
4289{
4290 // NOTE: destroyTrack_l() can remove a strong reference to this Track
4291 // by removing it from mTracks vector, so there is a risk that this Tracks's
Glenn Kasten99e53b82012-01-19 08:59:58 -08004292 // destructor is called. As the destructor needs to lock mLock,
Mathias Agopian65ab4712010-07-14 17:59:35 -07004293 // we must acquire a strong reference on this Track before locking mLock
4294 // here so that the destructor is called only when exiting this function.
4295 // On the other hand, as long as Track::destroy() is only called by
4296 // TrackHandle destructor, the TrackHandle still holds a strong ref on
4297 // this Track with its member mTrack.
4298 sp<Track> keep(this);
4299 { // scope for mLock
4300 sp<ThreadBase> thread = mThread.promote();
4301 if (thread != 0) {
4302 if (!isOutputTrack()) {
4303 if (mState == ACTIVE || mState == RESUMING) {
Glenn Kasten02bbd202012-02-08 12:35:35 -08004304 AudioSystem::stopOutput(thread->id(), mStreamType, mSessionId);
Gloria Wang9ee159b2011-02-24 14:51:45 -08004305
Glenn Kastend3cee2f2012-03-13 17:55:35 -07004306#ifdef ADD_BATTERY_DATA
Gloria Wang9ee159b2011-02-24 14:51:45 -08004307 // to track the speaker usage
4308 addBatteryData(IMediaPlayerService::kBatteryDataAudioFlingerStop);
Glenn Kastend3cee2f2012-03-13 17:55:35 -07004309#endif
Mathias Agopian65ab4712010-07-14 17:59:35 -07004310 }
4311 AudioSystem::releaseOutput(thread->id());
4312 }
4313 Mutex::Autolock _l(thread->mLock);
4314 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
4315 playbackThread->destroyTrack_l(this);
4316 }
4317 }
4318}
4319
Glenn Kasten288ed212012-04-25 17:52:27 -07004320/*static*/ void AudioFlinger::PlaybackThread::Track::appendDumpHeader(String8& result)
4321{
Glenn Kastene213c862012-04-25 13:46:15 -07004322 result.append(" Name Client Type Fmt Chn mask Session mFrCnt fCount S M F SRate L dB R dB "
Glenn Kastenbf0d21f2012-05-31 14:59:29 -07004323 " Server User Main buf Aux Buf Flags Underruns\n");
Glenn Kasten288ed212012-04-25 17:52:27 -07004324}
4325
Mathias Agopian65ab4712010-07-14 17:59:35 -07004326void AudioFlinger::PlaybackThread::Track::dump(char* buffer, size_t size)
4327{
Glenn Kasten83d86532012-01-17 14:39:34 -08004328 uint32_t vlr = mCblk->getVolumeLR();
Glenn Kasten58912562012-04-03 10:45:00 -07004329 if (isFastTrack()) {
Glenn Kasten288ed212012-04-25 17:52:27 -07004330 sprintf(buffer, " F %2d", mFastIndex);
Glenn Kasten58912562012-04-03 10:45:00 -07004331 } else {
4332 sprintf(buffer, " %4d", mName - AudioMixer::TRACK0);
4333 }
Glenn Kasten288ed212012-04-25 17:52:27 -07004334 track_state state = mState;
4335 char stateChar;
4336 switch (state) {
4337 case IDLE:
4338 stateChar = 'I';
4339 break;
4340 case TERMINATED:
4341 stateChar = 'T';
4342 break;
Glenn Kastend08f48c2012-05-01 18:14:02 -07004343 case STOPPING_1:
4344 stateChar = 's';
4345 break;
4346 case STOPPING_2:
4347 stateChar = '5';
4348 break;
Glenn Kasten288ed212012-04-25 17:52:27 -07004349 case STOPPED:
4350 stateChar = 'S';
4351 break;
4352 case RESUMING:
4353 stateChar = 'R';
4354 break;
4355 case ACTIVE:
4356 stateChar = 'A';
4357 break;
4358 case PAUSING:
4359 stateChar = 'p';
4360 break;
4361 case PAUSED:
4362 stateChar = 'P';
4363 break;
Eric Laurent29864602012-05-08 18:57:51 -07004364 case FLUSHED:
4365 stateChar = 'F';
4366 break;
Glenn Kasten288ed212012-04-25 17:52:27 -07004367 default:
4368 stateChar = '?';
4369 break;
4370 }
Glenn Kasten09474df2012-05-10 14:48:07 -07004371 char nowInUnderrun;
4372 switch (mObservedUnderruns.mBitFields.mMostRecent) {
4373 case UNDERRUN_FULL:
4374 nowInUnderrun = ' ';
4375 break;
4376 case UNDERRUN_PARTIAL:
4377 nowInUnderrun = '<';
4378 break;
4379 case UNDERRUN_EMPTY:
4380 nowInUnderrun = '*';
4381 break;
4382 default:
4383 nowInUnderrun = '?';
4384 break;
4385 }
Glenn Kastene213c862012-04-25 13:46:15 -07004386 snprintf(&buffer[7], size-7, " %6d %4u %3u 0x%08x %7u %6u %6u %1c %1d %1d %5u %5.2g %5.2g "
4387 "0x%08x 0x%08x 0x%08x 0x%08x %#5x %9u%c\n",
Glenn Kasten44deb052012-02-05 18:09:08 -08004388 (mClient == 0) ? getpid_cached : mClient->pid(),
Mathias Agopian65ab4712010-07-14 17:59:35 -07004389 mStreamType,
4390 mFormat,
Jean-Michel Trivi0d255b22011-05-24 15:53:33 -07004391 mChannelMask,
Mathias Agopian65ab4712010-07-14 17:59:35 -07004392 mSessionId,
4393 mFrameCount,
Glenn Kastene213c862012-04-25 13:46:15 -07004394 mCblk->frameCount,
Glenn Kasten288ed212012-04-25 17:52:27 -07004395 stateChar,
Mathias Agopian65ab4712010-07-14 17:59:35 -07004396 mMute,
4397 mFillingUpStatus,
4398 mCblk->sampleRate,
Glenn Kasten58912562012-04-03 10:45:00 -07004399 20.0 * log10((vlr & 0xFFFF) / 4096.0),
4400 20.0 * log10((vlr >> 16) / 4096.0),
Mathias Agopian65ab4712010-07-14 17:59:35 -07004401 mCblk->server,
4402 mCblk->user,
4403 (int)mMainBuffer,
Glenn Kasten288ed212012-04-25 17:52:27 -07004404 (int)mAuxBuffer,
Glenn Kastene213c862012-04-25 13:46:15 -07004405 mCblk->flags,
Glenn Kasten288ed212012-04-25 17:52:27 -07004406 mUnderrunCount,
Glenn Kasten09474df2012-05-10 14:48:07 -07004407 nowInUnderrun);
Mathias Agopian65ab4712010-07-14 17:59:35 -07004408}
4409
Glenn Kasten01c4ebf2012-02-22 10:47:35 -08004410// AudioBufferProvider interface
John Grossman4ff14ba2012-02-08 16:37:41 -08004411status_t AudioFlinger::PlaybackThread::Track::getNextBuffer(
Glenn Kastene53b9ea2012-03-12 16:29:55 -07004412 AudioBufferProvider::Buffer* buffer, int64_t pts)
Mathias Agopian65ab4712010-07-14 17:59:35 -07004413{
Glenn Kastene53b9ea2012-03-12 16:29:55 -07004414 audio_track_cblk_t* cblk = this->cblk();
4415 uint32_t framesReady;
4416 uint32_t framesReq = buffer->frameCount;
Mathias Agopian65ab4712010-07-14 17:59:35 -07004417
Glenn Kastene53b9ea2012-03-12 16:29:55 -07004418 // Check if last stepServer failed, try to step now
4419 if (mStepServerFailed) {
Glenn Kasten288ed212012-04-25 17:52:27 -07004420 // FIXME When called by fast mixer, this takes a mutex with tryLock().
4421 // Since the fast mixer is higher priority than client callback thread,
4422 // it does not result in priority inversion for client.
4423 // But a non-blocking solution would be preferable to avoid
4424 // fast mixer being unable to tryLock(), and
4425 // to avoid the extra context switches if the client wakes up,
4426 // discovers the mutex is locked, then has to wait for fast mixer to unlock.
Glenn Kastene53b9ea2012-03-12 16:29:55 -07004427 if (!step()) goto getNextBuffer_exit;
4428 ALOGV("stepServer recovered");
4429 mStepServerFailed = false;
4430 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07004431
Glenn Kasten288ed212012-04-25 17:52:27 -07004432 // FIXME Same as above
Glenn Kastene53b9ea2012-03-12 16:29:55 -07004433 framesReady = cblk->framesReady();
Mathias Agopian65ab4712010-07-14 17:59:35 -07004434
Glenn Kastene53b9ea2012-03-12 16:29:55 -07004435 if (CC_LIKELY(framesReady)) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07004436 uint32_t s = cblk->server;
4437 uint32_t bufferEnd = cblk->serverBase + cblk->frameCount;
4438
4439 bufferEnd = (cblk->loopEnd < bufferEnd) ? cblk->loopEnd : bufferEnd;
4440 if (framesReq > framesReady) {
4441 framesReq = framesReady;
4442 }
Marco Nelissena1472d92012-03-30 14:36:54 -07004443 if (framesReq > bufferEnd - s) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07004444 framesReq = bufferEnd - s;
4445 }
4446
Glenn Kastene53b9ea2012-03-12 16:29:55 -07004447 buffer->raw = getBuffer(s, framesReq);
4448 if (buffer->raw == NULL) goto getNextBuffer_exit;
Mathias Agopian65ab4712010-07-14 17:59:35 -07004449
Glenn Kastene53b9ea2012-03-12 16:29:55 -07004450 buffer->frameCount = framesReq;
Mathias Agopian65ab4712010-07-14 17:59:35 -07004451 return NO_ERROR;
Glenn Kastene53b9ea2012-03-12 16:29:55 -07004452 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07004453
4454getNextBuffer_exit:
Glenn Kastene53b9ea2012-03-12 16:29:55 -07004455 buffer->raw = NULL;
4456 buffer->frameCount = 0;
4457 ALOGV("getNextBuffer() no more data for track %d on thread %p", mName, mThread.unsafe_get());
4458 return NOT_ENOUGH_DATA;
Mathias Agopian65ab4712010-07-14 17:59:35 -07004459}
4460
Glenn Kasten288ed212012-04-25 17:52:27 -07004461// Note that framesReady() takes a mutex on the control block using tryLock().
4462// This could result in priority inversion if framesReady() is called by the normal mixer,
4463// as the normal mixer thread runs at lower
4464// priority than the client's callback thread: there is a short window within framesReady()
4465// during which the normal mixer could be preempted, and the client callback would block.
4466// Another problem can occur if framesReady() is called by the fast mixer:
4467// the tryLock() could block for up to 1 ms, and a sequence of these could delay fast mixer.
4468// FIXME Replace AudioTrackShared control block implementation by a non-blocking FIFO queue.
4469size_t AudioFlinger::PlaybackThread::Track::framesReady() const {
John Grossman4ff14ba2012-02-08 16:37:41 -08004470 return mCblk->framesReady();
4471}
4472
Glenn Kasten288ed212012-04-25 17:52:27 -07004473// Don't call for fast tracks; the framesReady() could result in priority inversion
Mathias Agopian65ab4712010-07-14 17:59:35 -07004474bool AudioFlinger::PlaybackThread::Track::isReady() const {
Eric Laurentaf59ce22010-10-05 14:41:42 -07004475 if (mFillingUpStatus != FS_FILLING || isStopped() || isPausing()) return true;
Mathias Agopian65ab4712010-07-14 17:59:35 -07004476
John Grossman4ff14ba2012-02-08 16:37:41 -08004477 if (framesReady() >= mCblk->frameCount ||
Mathias Agopian65ab4712010-07-14 17:59:35 -07004478 (mCblk->flags & CBLK_FORCEREADY_MSK)) {
4479 mFillingUpStatus = FS_FILLED;
Eric Laurent38ccae22011-03-28 18:37:07 -07004480 android_atomic_and(~CBLK_FORCEREADY_MSK, &mCblk->flags);
Mathias Agopian65ab4712010-07-14 17:59:35 -07004481 return true;
4482 }
4483 return false;
4484}
4485
Glenn Kasten3acbd052012-02-28 10:39:56 -08004486status_t AudioFlinger::PlaybackThread::Track::start(AudioSystem::sync_event_t event,
Eric Laurenta011e352012-03-29 15:51:43 -07004487 int triggerSession)
Mathias Agopian65ab4712010-07-14 17:59:35 -07004488{
4489 status_t status = NO_ERROR;
Glenn Kasten58912562012-04-03 10:45:00 -07004490 ALOGV("start(%d), calling pid %d session %d",
4491 mName, IPCThreadState::self()->getCallingPid(), mSessionId);
Glenn Kasten3acbd052012-02-28 10:39:56 -08004492
Mathias Agopian65ab4712010-07-14 17:59:35 -07004493 sp<ThreadBase> thread = mThread.promote();
4494 if (thread != 0) {
4495 Mutex::Autolock _l(thread->mLock);
Glenn Kastenb853e982012-01-26 13:39:18 -08004496 track_state state = mState;
Mathias Agopian65ab4712010-07-14 17:59:35 -07004497 // here the track could be either new, or restarted
4498 // in both cases "unstop" the track
4499 if (mState == PAUSED) {
4500 mState = TrackBase::RESUMING;
Steve Block3856b092011-10-20 11:56:00 +01004501 ALOGV("PAUSED => RESUMING (%d) on thread %p", mName, this);
Mathias Agopian65ab4712010-07-14 17:59:35 -07004502 } else {
4503 mState = TrackBase::ACTIVE;
Steve Block3856b092011-10-20 11:56:00 +01004504 ALOGV("? => ACTIVE (%d) on thread %p", mName, this);
Mathias Agopian65ab4712010-07-14 17:59:35 -07004505 }
4506
4507 if (!isOutputTrack() && state != ACTIVE && state != RESUMING) {
4508 thread->mLock.unlock();
Glenn Kasten02bbd202012-02-08 12:35:35 -08004509 status = AudioSystem::startOutput(thread->id(), mStreamType, mSessionId);
Mathias Agopian65ab4712010-07-14 17:59:35 -07004510 thread->mLock.lock();
Gloria Wang9ee159b2011-02-24 14:51:45 -08004511
Glenn Kastend3cee2f2012-03-13 17:55:35 -07004512#ifdef ADD_BATTERY_DATA
Gloria Wang9ee159b2011-02-24 14:51:45 -08004513 // to track the speaker usage
4514 if (status == NO_ERROR) {
4515 addBatteryData(IMediaPlayerService::kBatteryDataAudioFlingerStart);
4516 }
Glenn Kastend3cee2f2012-03-13 17:55:35 -07004517#endif
Mathias Agopian65ab4712010-07-14 17:59:35 -07004518 }
4519 if (status == NO_ERROR) {
4520 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
4521 playbackThread->addTrack_l(this);
4522 } else {
4523 mState = state;
Eric Laurent29864602012-05-08 18:57:51 -07004524 triggerEvents(AudioSystem::SYNC_EVENT_PRESENTATION_COMPLETE);
Mathias Agopian65ab4712010-07-14 17:59:35 -07004525 }
4526 } else {
4527 status = BAD_VALUE;
4528 }
4529 return status;
4530}
4531
4532void AudioFlinger::PlaybackThread::Track::stop()
4533{
Glenn Kasten23d82a92012-02-03 11:10:00 -08004534 ALOGV("stop(%d), calling pid %d", mName, IPCThreadState::self()->getCallingPid());
Mathias Agopian65ab4712010-07-14 17:59:35 -07004535 sp<ThreadBase> thread = mThread.promote();
4536 if (thread != 0) {
4537 Mutex::Autolock _l(thread->mLock);
Glenn Kastenb853e982012-01-26 13:39:18 -08004538 track_state state = mState;
Glenn Kastend08f48c2012-05-01 18:14:02 -07004539 if (state == RESUMING || state == ACTIVE || state == PAUSING || state == PAUSED) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07004540 // If the track is not active (PAUSED and buffers full), flush buffers
4541 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
4542 if (playbackThread->mActiveTracks.indexOf(this) < 0) {
4543 reset();
Glenn Kastend08f48c2012-05-01 18:14:02 -07004544 mState = STOPPED;
4545 } else if (!isFastTrack()) {
4546 mState = STOPPED;
4547 } else {
4548 // prepareTracks_l() will set state to STOPPING_2 after next underrun,
4549 // and then to STOPPED and reset() when presentation is complete
4550 mState = STOPPING_1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07004551 }
Glenn Kastend08f48c2012-05-01 18:14:02 -07004552 ALOGV("not stopping/stopped => stopping/stopped (%d) on thread %p", mName, playbackThread);
Mathias Agopian65ab4712010-07-14 17:59:35 -07004553 }
4554 if (!isOutputTrack() && (state == ACTIVE || state == RESUMING)) {
4555 thread->mLock.unlock();
Glenn Kasten02bbd202012-02-08 12:35:35 -08004556 AudioSystem::stopOutput(thread->id(), mStreamType, mSessionId);
Mathias Agopian65ab4712010-07-14 17:59:35 -07004557 thread->mLock.lock();
Gloria Wang9ee159b2011-02-24 14:51:45 -08004558
Glenn Kastend3cee2f2012-03-13 17:55:35 -07004559#ifdef ADD_BATTERY_DATA
Gloria Wang9ee159b2011-02-24 14:51:45 -08004560 // to track the speaker usage
4561 addBatteryData(IMediaPlayerService::kBatteryDataAudioFlingerStop);
Glenn Kastend3cee2f2012-03-13 17:55:35 -07004562#endif
Mathias Agopian65ab4712010-07-14 17:59:35 -07004563 }
4564 }
4565}
4566
4567void AudioFlinger::PlaybackThread::Track::pause()
4568{
Glenn Kasten23d82a92012-02-03 11:10:00 -08004569 ALOGV("pause(%d), calling pid %d", mName, IPCThreadState::self()->getCallingPid());
Mathias Agopian65ab4712010-07-14 17:59:35 -07004570 sp<ThreadBase> thread = mThread.promote();
4571 if (thread != 0) {
4572 Mutex::Autolock _l(thread->mLock);
4573 if (mState == ACTIVE || mState == RESUMING) {
4574 mState = PAUSING;
Steve Block3856b092011-10-20 11:56:00 +01004575 ALOGV("ACTIVE/RESUMING => PAUSING (%d) on thread %p", mName, thread.get());
Mathias Agopian65ab4712010-07-14 17:59:35 -07004576 if (!isOutputTrack()) {
4577 thread->mLock.unlock();
Glenn Kasten02bbd202012-02-08 12:35:35 -08004578 AudioSystem::stopOutput(thread->id(), mStreamType, mSessionId);
Mathias Agopian65ab4712010-07-14 17:59:35 -07004579 thread->mLock.lock();
Gloria Wang9ee159b2011-02-24 14:51:45 -08004580
Glenn Kastend3cee2f2012-03-13 17:55:35 -07004581#ifdef ADD_BATTERY_DATA
Gloria Wang9ee159b2011-02-24 14:51:45 -08004582 // to track the speaker usage
4583 addBatteryData(IMediaPlayerService::kBatteryDataAudioFlingerStop);
Glenn Kastend3cee2f2012-03-13 17:55:35 -07004584#endif
Mathias Agopian65ab4712010-07-14 17:59:35 -07004585 }
4586 }
4587 }
4588}
4589
4590void AudioFlinger::PlaybackThread::Track::flush()
4591{
Steve Block3856b092011-10-20 11:56:00 +01004592 ALOGV("flush(%d)", mName);
Mathias Agopian65ab4712010-07-14 17:59:35 -07004593 sp<ThreadBase> thread = mThread.promote();
4594 if (thread != 0) {
4595 Mutex::Autolock _l(thread->mLock);
Glenn Kastend08f48c2012-05-01 18:14:02 -07004596 if (mState != STOPPING_1 && mState != STOPPING_2 && mState != STOPPED && mState != PAUSED &&
4597 mState != PAUSING) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07004598 return;
4599 }
4600 // No point remaining in PAUSED state after a flush => go to
Eric Laurent29864602012-05-08 18:57:51 -07004601 // FLUSHED state
4602 mState = FLUSHED;
Eric Laurent38ccae22011-03-28 18:37:07 -07004603 // do not reset the track if it is still in the process of being stopped or paused.
4604 // this will be done by prepareTracks_l() when the track is stopped.
Eric Laurent29864602012-05-08 18:57:51 -07004605 // prepareTracks_l() will see mState == FLUSHED, then
Glenn Kastend08f48c2012-05-01 18:14:02 -07004606 // remove from active track list, reset(), and trigger presentation complete
Eric Laurent38ccae22011-03-28 18:37:07 -07004607 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
4608 if (playbackThread->mActiveTracks.indexOf(this) < 0) {
4609 reset();
4610 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07004611 }
4612}
4613
4614void AudioFlinger::PlaybackThread::Track::reset()
4615{
4616 // Do not reset twice to avoid discarding data written just after a flush and before
4617 // the audioflinger thread detects the track is stopped.
4618 if (!mResetDone) {
4619 TrackBase::reset();
4620 // Force underrun condition to avoid false underrun callback until first data is
4621 // written to buffer
Eric Laurent38ccae22011-03-28 18:37:07 -07004622 android_atomic_and(~CBLK_FORCEREADY_MSK, &mCblk->flags);
4623 android_atomic_or(CBLK_UNDERRUN_ON, &mCblk->flags);
Mathias Agopian65ab4712010-07-14 17:59:35 -07004624 mFillingUpStatus = FS_FILLING;
4625 mResetDone = true;
Eric Laurent29864602012-05-08 18:57:51 -07004626 if (mState == FLUSHED) {
4627 mState = IDLE;
4628 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07004629 }
4630}
4631
4632void AudioFlinger::PlaybackThread::Track::mute(bool muted)
4633{
4634 mMute = muted;
4635}
4636
Mathias Agopian65ab4712010-07-14 17:59:35 -07004637status_t AudioFlinger::PlaybackThread::Track::attachAuxEffect(int EffectId)
4638{
4639 status_t status = DEAD_OBJECT;
4640 sp<ThreadBase> thread = mThread.promote();
4641 if (thread != 0) {
Glenn Kastene53b9ea2012-03-12 16:29:55 -07004642 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
4643 status = playbackThread->attachAuxEffect(this, EffectId);
Mathias Agopian65ab4712010-07-14 17:59:35 -07004644 }
4645 return status;
4646}
4647
4648void AudioFlinger::PlaybackThread::Track::setAuxBuffer(int EffectId, int32_t *buffer)
4649{
4650 mAuxEffectId = EffectId;
4651 mAuxBuffer = buffer;
4652}
4653
Eric Laurenta011e352012-03-29 15:51:43 -07004654bool AudioFlinger::PlaybackThread::Track::presentationComplete(size_t framesWritten,
4655 size_t audioHalFrames)
4656{
4657 // a track is considered presented when the total number of frames written to audio HAL
4658 // corresponds to the number of frames written when presentationComplete() is called for the
4659 // first time (mPresentationCompleteFrames == 0) plus the buffer filling status at that time.
4660 if (mPresentationCompleteFrames == 0) {
4661 mPresentationCompleteFrames = framesWritten + audioHalFrames;
4662 ALOGV("presentationComplete() reset: mPresentationCompleteFrames %d audioHalFrames %d",
4663 mPresentationCompleteFrames, audioHalFrames);
4664 }
4665 if (framesWritten >= mPresentationCompleteFrames) {
4666 ALOGV("presentationComplete() session %d complete: framesWritten %d",
4667 mSessionId, framesWritten);
4668 triggerEvents(AudioSystem::SYNC_EVENT_PRESENTATION_COMPLETE);
Eric Laurenta011e352012-03-29 15:51:43 -07004669 return true;
4670 }
4671 return false;
4672}
4673
4674void AudioFlinger::PlaybackThread::Track::triggerEvents(AudioSystem::sync_event_t type)
4675{
4676 for (int i = 0; i < (int)mSyncEvents.size(); i++) {
4677 if (mSyncEvents[i]->type() == type) {
4678 mSyncEvents[i]->trigger();
4679 mSyncEvents.removeAt(i);
4680 i--;
4681 }
4682 }
4683}
4684
Glenn Kasten58912562012-04-03 10:45:00 -07004685// implement VolumeBufferProvider interface
4686
4687uint32_t AudioFlinger::PlaybackThread::Track::getVolumeLR()
4688{
4689 // called by FastMixer, so not allowed to take any locks, block, or do I/O including logs
4690 ALOG_ASSERT(isFastTrack() && (mCblk != NULL));
4691 uint32_t vlr = mCblk->getVolumeLR();
4692 uint32_t vl = vlr & 0xFFFF;
4693 uint32_t vr = vlr >> 16;
4694 // track volumes come from shared memory, so can't be trusted and must be clamped
4695 if (vl > MAX_GAIN_INT) {
4696 vl = MAX_GAIN_INT;
4697 }
4698 if (vr > MAX_GAIN_INT) {
4699 vr = MAX_GAIN_INT;
4700 }
4701 // now apply the cached master volume and stream type volume;
4702 // this is trusted but lacks any synchronization or barrier so may be stale
4703 float v = mCachedVolume;
4704 vl *= v;
4705 vr *= v;
4706 // re-combine into U4.16
4707 vlr = (vr << 16) | (vl & 0xFFFF);
4708 // FIXME look at mute, pause, and stop flags
4709 return vlr;
4710}
Eric Laurenta011e352012-03-29 15:51:43 -07004711
Eric Laurent29864602012-05-08 18:57:51 -07004712status_t AudioFlinger::PlaybackThread::Track::setSyncEvent(const sp<SyncEvent>& event)
4713{
4714 if (mState == TERMINATED || mState == PAUSED ||
4715 ((framesReady() == 0) && ((mSharedBuffer != 0) ||
4716 (mState == STOPPED)))) {
4717 ALOGW("Track::setSyncEvent() in invalid state %d on session %d %s mode, framesReady %d ",
4718 mState, mSessionId, (mSharedBuffer != 0) ? "static" : "stream", framesReady());
4719 event->cancel();
4720 return INVALID_OPERATION;
4721 }
4722 TrackBase::setSyncEvent(event);
4723 return NO_ERROR;
4724}
4725
John Grossman4ff14ba2012-02-08 16:37:41 -08004726// timed audio tracks
4727
4728sp<AudioFlinger::PlaybackThread::TimedTrack>
4729AudioFlinger::PlaybackThread::TimedTrack::create(
Glenn Kasten9eaa5572012-01-20 13:32:16 -08004730 PlaybackThread *thread,
John Grossman4ff14ba2012-02-08 16:37:41 -08004731 const sp<Client>& client,
4732 audio_stream_type_t streamType,
4733 uint32_t sampleRate,
4734 audio_format_t format,
4735 uint32_t channelMask,
4736 int frameCount,
4737 const sp<IMemory>& sharedBuffer,
4738 int sessionId) {
4739 if (!client->reserveTimedTrack())
4740 return NULL;
4741
Glenn Kastena0356762012-03-19 10:38:51 -07004742 return new TimedTrack(
John Grossman4ff14ba2012-02-08 16:37:41 -08004743 thread, client, streamType, sampleRate, format, channelMask, frameCount,
4744 sharedBuffer, sessionId);
John Grossman4ff14ba2012-02-08 16:37:41 -08004745}
4746
4747AudioFlinger::PlaybackThread::TimedTrack::TimedTrack(
Glenn Kasten9eaa5572012-01-20 13:32:16 -08004748 PlaybackThread *thread,
John Grossman4ff14ba2012-02-08 16:37:41 -08004749 const sp<Client>& client,
4750 audio_stream_type_t streamType,
4751 uint32_t sampleRate,
4752 audio_format_t format,
4753 uint32_t channelMask,
4754 int frameCount,
4755 const sp<IMemory>& sharedBuffer,
4756 int sessionId)
4757 : Track(thread, client, streamType, sampleRate, format, channelMask,
Glenn Kasten73d22752012-03-19 13:38:30 -07004758 frameCount, sharedBuffer, sessionId, IAudioFlinger::TRACK_TIMED),
John Grossman9fbdee12012-03-26 17:51:46 -07004759 mQueueHeadInFlight(false),
4760 mTrimQueueHeadOnRelease(false),
John Grossman1c345192012-03-27 14:00:17 -07004761 mFramesPendingInQueue(0),
John Grossman4ff14ba2012-02-08 16:37:41 -08004762 mTimedSilenceBuffer(NULL),
4763 mTimedSilenceBufferSize(0),
4764 mTimedAudioOutputOnTime(false),
4765 mMediaTimeTransformValid(false)
4766{
4767 LocalClock lc;
4768 mLocalTimeFreq = lc.getLocalFreq();
4769
4770 mLocalTimeToSampleTransform.a_zero = 0;
4771 mLocalTimeToSampleTransform.b_zero = 0;
4772 mLocalTimeToSampleTransform.a_to_b_numer = sampleRate;
4773 mLocalTimeToSampleTransform.a_to_b_denom = mLocalTimeFreq;
4774 LinearTransform::reduce(&mLocalTimeToSampleTransform.a_to_b_numer,
4775 &mLocalTimeToSampleTransform.a_to_b_denom);
John Grossman9fbdee12012-03-26 17:51:46 -07004776
4777 mMediaTimeToSampleTransform.a_zero = 0;
4778 mMediaTimeToSampleTransform.b_zero = 0;
4779 mMediaTimeToSampleTransform.a_to_b_numer = sampleRate;
4780 mMediaTimeToSampleTransform.a_to_b_denom = 1000000;
4781 LinearTransform::reduce(&mMediaTimeToSampleTransform.a_to_b_numer,
4782 &mMediaTimeToSampleTransform.a_to_b_denom);
John Grossman4ff14ba2012-02-08 16:37:41 -08004783}
4784
4785AudioFlinger::PlaybackThread::TimedTrack::~TimedTrack() {
4786 mClient->releaseTimedTrack();
4787 delete [] mTimedSilenceBuffer;
4788}
4789
4790status_t AudioFlinger::PlaybackThread::TimedTrack::allocateTimedBuffer(
4791 size_t size, sp<IMemory>* buffer) {
4792
4793 Mutex::Autolock _l(mTimedBufferQueueLock);
4794
4795 trimTimedBufferQueue_l();
4796
4797 // lazily initialize the shared memory heap for timed buffers
4798 if (mTimedMemoryDealer == NULL) {
4799 const int kTimedBufferHeapSize = 512 << 10;
4800
4801 mTimedMemoryDealer = new MemoryDealer(kTimedBufferHeapSize,
4802 "AudioFlingerTimed");
4803 if (mTimedMemoryDealer == NULL)
4804 return NO_MEMORY;
4805 }
4806
4807 sp<IMemory> newBuffer = mTimedMemoryDealer->allocate(size);
4808 if (newBuffer == NULL) {
4809 newBuffer = mTimedMemoryDealer->allocate(size);
4810 if (newBuffer == NULL)
4811 return NO_MEMORY;
4812 }
4813
4814 *buffer = newBuffer;
4815 return NO_ERROR;
4816}
4817
4818// caller must hold mTimedBufferQueueLock
4819void AudioFlinger::PlaybackThread::TimedTrack::trimTimedBufferQueue_l() {
4820 int64_t mediaTimeNow;
4821 {
4822 Mutex::Autolock mttLock(mMediaTimeTransformLock);
4823 if (!mMediaTimeTransformValid)
4824 return;
4825
4826 int64_t targetTimeNow;
4827 status_t res = (mMediaTimeTransformTarget == TimedAudioTrack::COMMON_TIME)
4828 ? mCCHelper.getCommonTime(&targetTimeNow)
4829 : mCCHelper.getLocalTime(&targetTimeNow);
4830
4831 if (OK != res)
4832 return;
4833
4834 if (!mMediaTimeTransform.doReverseTransform(targetTimeNow,
4835 &mediaTimeNow)) {
4836 return;
4837 }
4838 }
4839
John Grossman1c345192012-03-27 14:00:17 -07004840 size_t trimEnd;
4841 for (trimEnd = 0; trimEnd < mTimedBufferQueue.size(); trimEnd++) {
John Grossman9fbdee12012-03-26 17:51:46 -07004842 int64_t bufEnd;
4843
John Grossmanc95cfbb2012-04-12 11:53:11 -07004844 if ((trimEnd + 1) < mTimedBufferQueue.size()) {
4845 // We have a next buffer. Just use its PTS as the PTS of the frame
4846 // following the last frame in this buffer. If the stream is sparse
4847 // (ie, there are deliberate gaps left in the stream which should be
4848 // filled with silence by the TimedAudioTrack), then this can result
4849 // in one extra buffer being left un-trimmed when it could have
4850 // been. In general, this is not typical, and we would rather
4851 // optimized away the TS calculation below for the more common case
4852 // where PTSes are contiguous.
4853 bufEnd = mTimedBufferQueue[trimEnd + 1].pts();
4854 } else {
4855 // We have no next buffer. Compute the PTS of the frame following
4856 // the last frame in this buffer by computing the duration of of
4857 // this frame in media time units and adding it to the PTS of the
4858 // buffer.
4859 int64_t frameCount = mTimedBufferQueue[trimEnd].buffer()->size()
4860 / mCblk->frameSize;
4861
4862 if (!mMediaTimeToSampleTransform.doReverseTransform(frameCount,
4863 &bufEnd)) {
4864 ALOGE("Failed to convert frame count of %lld to media time"
4865 " duration" " (scale factor %d/%u) in %s",
4866 frameCount,
4867 mMediaTimeToSampleTransform.a_to_b_numer,
4868 mMediaTimeToSampleTransform.a_to_b_denom,
4869 __PRETTY_FUNCTION__);
4870 break;
4871 }
4872 bufEnd += mTimedBufferQueue[trimEnd].pts();
John Grossman9fbdee12012-03-26 17:51:46 -07004873 }
John Grossman9fbdee12012-03-26 17:51:46 -07004874
4875 if (bufEnd > mediaTimeNow)
4876 break;
4877
4878 // Is the buffer we want to use in the middle of a mix operation right
4879 // now? If so, don't actually trim it. Just wait for the releaseBuffer
4880 // from the mixer which should be coming back shortly.
John Grossman1c345192012-03-27 14:00:17 -07004881 if (!trimEnd && mQueueHeadInFlight) {
John Grossman9fbdee12012-03-26 17:51:46 -07004882 mTrimQueueHeadOnRelease = true;
4883 }
John Grossman4ff14ba2012-02-08 16:37:41 -08004884 }
4885
John Grossman9fbdee12012-03-26 17:51:46 -07004886 size_t trimStart = mTrimQueueHeadOnRelease ? 1 : 0;
John Grossman1c345192012-03-27 14:00:17 -07004887 if (trimStart < trimEnd) {
4888 // Update the bookkeeping for framesReady()
4889 for (size_t i = trimStart; i < trimEnd; ++i) {
4890 updateFramesPendingAfterTrim_l(mTimedBufferQueue[i], "trim");
4891 }
4892
4893 // Now actually remove the buffers from the queue.
4894 mTimedBufferQueue.removeItemsAt(trimStart, trimEnd);
John Grossman4ff14ba2012-02-08 16:37:41 -08004895 }
4896}
4897
John Grossman1c345192012-03-27 14:00:17 -07004898void AudioFlinger::PlaybackThread::TimedTrack::trimTimedBufferQueueHead_l(
4899 const char* logTag) {
John Grossmand3030da2012-04-12 11:56:36 -07004900 ALOG_ASSERT(mTimedBufferQueue.size() > 0,
4901 "%s called (reason \"%s\"), but timed buffer queue has no"
4902 " elements to trim.", __FUNCTION__, logTag);
John Grossman1c345192012-03-27 14:00:17 -07004903
4904 updateFramesPendingAfterTrim_l(mTimedBufferQueue[0], logTag);
4905 mTimedBufferQueue.removeAt(0);
4906}
4907
4908void AudioFlinger::PlaybackThread::TimedTrack::updateFramesPendingAfterTrim_l(
4909 const TimedBuffer& buf,
4910 const char* logTag) {
4911 uint32_t bufBytes = buf.buffer()->size();
4912 uint32_t consumedAlready = buf.position();
4913
Eric Laurentb388e532012-04-14 13:32:48 -07004914 ALOG_ASSERT(consumedAlready <= bufBytes,
John Grossmand3030da2012-04-12 11:56:36 -07004915 "Bad bookkeeping while updating frames pending. Timed buffer is"
4916 " only %u bytes long, but claims to have consumed %u"
4917 " bytes. (update reason: \"%s\")",
Eric Laurentb388e532012-04-14 13:32:48 -07004918 bufBytes, consumedAlready, logTag);
John Grossman1c345192012-03-27 14:00:17 -07004919
4920 uint32_t bufFrames = (bufBytes - consumedAlready) / mCblk->frameSize;
John Grossmand3030da2012-04-12 11:56:36 -07004921 ALOG_ASSERT(mFramesPendingInQueue >= bufFrames,
4922 "Bad bookkeeping while updating frames pending. Should have at"
4923 " least %u queued frames, but we think we have only %u. (update"
4924 " reason: \"%s\")",
4925 bufFrames, mFramesPendingInQueue, logTag);
John Grossman1c345192012-03-27 14:00:17 -07004926
4927 mFramesPendingInQueue -= bufFrames;
4928}
4929
John Grossman4ff14ba2012-02-08 16:37:41 -08004930status_t AudioFlinger::PlaybackThread::TimedTrack::queueTimedBuffer(
4931 const sp<IMemory>& buffer, int64_t pts) {
4932
4933 {
4934 Mutex::Autolock mttLock(mMediaTimeTransformLock);
4935 if (!mMediaTimeTransformValid)
4936 return INVALID_OPERATION;
4937 }
4938
4939 Mutex::Autolock _l(mTimedBufferQueueLock);
4940
John Grossman1c345192012-03-27 14:00:17 -07004941 uint32_t bufFrames = buffer->size() / mCblk->frameSize;
4942 mFramesPendingInQueue += bufFrames;
John Grossman4ff14ba2012-02-08 16:37:41 -08004943 mTimedBufferQueue.add(TimedBuffer(buffer, pts));
4944
4945 return NO_ERROR;
4946}
4947
4948status_t AudioFlinger::PlaybackThread::TimedTrack::setMediaTimeTransform(
4949 const LinearTransform& xform, TimedAudioTrack::TargetTimeline target) {
4950
John Grossman1c345192012-03-27 14:00:17 -07004951 ALOGVV("setMediaTimeTransform az=%lld bz=%lld n=%d d=%u tgt=%d",
4952 xform.a_zero, xform.b_zero, xform.a_to_b_numer, xform.a_to_b_denom,
4953 target);
John Grossman4ff14ba2012-02-08 16:37:41 -08004954
4955 if (!(target == TimedAudioTrack::LOCAL_TIME ||
4956 target == TimedAudioTrack::COMMON_TIME)) {
4957 return BAD_VALUE;
4958 }
4959
4960 Mutex::Autolock lock(mMediaTimeTransformLock);
4961 mMediaTimeTransform = xform;
4962 mMediaTimeTransformTarget = target;
4963 mMediaTimeTransformValid = true;
4964
4965 return NO_ERROR;
4966}
4967
4968#define min(a, b) ((a) < (b) ? (a) : (b))
4969
4970// implementation of getNextBuffer for tracks whose buffers have timestamps
4971status_t AudioFlinger::PlaybackThread::TimedTrack::getNextBuffer(
4972 AudioBufferProvider::Buffer* buffer, int64_t pts)
4973{
4974 if (pts == AudioBufferProvider::kInvalidPTS) {
4975 buffer->raw = 0;
4976 buffer->frameCount = 0;
John Grossman8d314b72012-04-19 12:08:17 -07004977 mTimedAudioOutputOnTime = false;
John Grossman4ff14ba2012-02-08 16:37:41 -08004978 return INVALID_OPERATION;
4979 }
4980
John Grossman4ff14ba2012-02-08 16:37:41 -08004981 Mutex::Autolock _l(mTimedBufferQueueLock);
4982
John Grossman9fbdee12012-03-26 17:51:46 -07004983 ALOG_ASSERT(!mQueueHeadInFlight,
4984 "getNextBuffer called without releaseBuffer!");
4985
John Grossman4ff14ba2012-02-08 16:37:41 -08004986 while (true) {
4987
4988 // if we have no timed buffers, then fail
4989 if (mTimedBufferQueue.isEmpty()) {
4990 buffer->raw = 0;
4991 buffer->frameCount = 0;
4992 return NOT_ENOUGH_DATA;
4993 }
4994
4995 TimedBuffer& head = mTimedBufferQueue.editItemAt(0);
4996
4997 // calculate the PTS of the head of the timed buffer queue expressed in
4998 // local time
4999 int64_t headLocalPTS;
5000 {
5001 Mutex::Autolock mttLock(mMediaTimeTransformLock);
5002
Glenn Kasten5798d4e2012-03-08 12:18:35 -08005003 ALOG_ASSERT(mMediaTimeTransformValid, "media time transform invalid");
John Grossman4ff14ba2012-02-08 16:37:41 -08005004
5005 if (mMediaTimeTransform.a_to_b_denom == 0) {
5006 // the transform represents a pause, so yield silence
John Grossman9fbdee12012-03-26 17:51:46 -07005007 timedYieldSilence_l(buffer->frameCount, buffer);
John Grossman4ff14ba2012-02-08 16:37:41 -08005008 return NO_ERROR;
5009 }
5010
5011 int64_t transformedPTS;
5012 if (!mMediaTimeTransform.doForwardTransform(head.pts(),
5013 &transformedPTS)) {
5014 // the transform failed. this shouldn't happen, but if it does
5015 // then just drop this buffer
5016 ALOGW("timedGetNextBuffer transform failed");
5017 buffer->raw = 0;
5018 buffer->frameCount = 0;
John Grossman1c345192012-03-27 14:00:17 -07005019 trimTimedBufferQueueHead_l("getNextBuffer; no transform");
John Grossman4ff14ba2012-02-08 16:37:41 -08005020 return NO_ERROR;
5021 }
5022
5023 if (mMediaTimeTransformTarget == TimedAudioTrack::COMMON_TIME) {
5024 if (OK != mCCHelper.commonTimeToLocalTime(transformedPTS,
5025 &headLocalPTS)) {
5026 buffer->raw = 0;
5027 buffer->frameCount = 0;
5028 return INVALID_OPERATION;
5029 }
5030 } else {
5031 headLocalPTS = transformedPTS;
5032 }
5033 }
5034
5035 // adjust the head buffer's PTS to reflect the portion of the head buffer
5036 // that has already been consumed
5037 int64_t effectivePTS = headLocalPTS +
5038 ((head.position() / mCblk->frameSize) * mLocalTimeFreq / sampleRate());
5039
5040 // Calculate the delta in samples between the head of the input buffer
5041 // queue and the start of the next output buffer that will be written.
5042 // If the transformation fails because of over or underflow, it means
5043 // that the sample's position in the output stream is so far out of
5044 // whack that it should just be dropped.
5045 int64_t sampleDelta;
5046 if (llabs(effectivePTS - pts) >= (static_cast<int64_t>(1) << 31)) {
5047 ALOGV("*** head buffer is too far from PTS: dropped buffer");
John Grossman1c345192012-03-27 14:00:17 -07005048 trimTimedBufferQueueHead_l("getNextBuffer, buf pts too far from"
5049 " mix");
John Grossman4ff14ba2012-02-08 16:37:41 -08005050 continue;
5051 }
5052 if (!mLocalTimeToSampleTransform.doForwardTransform(
5053 (effectivePTS - pts) << 32, &sampleDelta)) {
John Grossmand3030da2012-04-12 11:56:36 -07005054 ALOGV("*** too late during sample rate transform: dropped buffer");
John Grossman1c345192012-03-27 14:00:17 -07005055 trimTimedBufferQueueHead_l("getNextBuffer, bad local to sample");
John Grossman4ff14ba2012-02-08 16:37:41 -08005056 continue;
5057 }
5058
John Grossman1c345192012-03-27 14:00:17 -07005059 ALOGVV("*** getNextBuffer head.pts=%lld head.pos=%d pts=%lld"
5060 " sampleDelta=[%d.%08x]",
5061 head.pts(), head.position(), pts,
5062 static_cast<int32_t>((sampleDelta >= 0 ? 0 : 1)
5063 + (sampleDelta >> 32)),
5064 static_cast<uint32_t>(sampleDelta & 0xFFFFFFFF));
John Grossman4ff14ba2012-02-08 16:37:41 -08005065
5066 // if the delta between the ideal placement for the next input sample and
5067 // the current output position is within this threshold, then we will
5068 // concatenate the next input samples to the previous output
5069 const int64_t kSampleContinuityThreshold =
John Grossman8d314b72012-04-19 12:08:17 -07005070 (static_cast<int64_t>(sampleRate()) << 32) / 250;
John Grossman4ff14ba2012-02-08 16:37:41 -08005071
5072 // if this is the first buffer of audio that we're emitting from this track
5073 // then it should be almost exactly on time.
5074 const int64_t kSampleStartupThreshold = 1LL << 32;
5075
5076 if ((mTimedAudioOutputOnTime && llabs(sampleDelta) <= kSampleContinuityThreshold) ||
John Grossman8d314b72012-04-19 12:08:17 -07005077 (!mTimedAudioOutputOnTime && llabs(sampleDelta) <= kSampleStartupThreshold)) {
John Grossman4ff14ba2012-02-08 16:37:41 -08005078 // the next input is close enough to being on time, so concatenate it
5079 // with the last output
John Grossman9fbdee12012-03-26 17:51:46 -07005080 timedYieldSamples_l(buffer);
John Grossman4ff14ba2012-02-08 16:37:41 -08005081
John Grossman1c345192012-03-27 14:00:17 -07005082 ALOGVV("*** on time: head.pos=%d frameCount=%u",
5083 head.position(), buffer->frameCount);
John Grossman4ff14ba2012-02-08 16:37:41 -08005084 return NO_ERROR;
John Grossman8d314b72012-04-19 12:08:17 -07005085 }
5086
5087 // Looks like our output is not on time. Reset our on timed status.
5088 // Next time we mix samples from our input queue, then should be within
5089 // the StartupThreshold.
5090 mTimedAudioOutputOnTime = false;
5091 if (sampleDelta > 0) {
John Grossman4ff14ba2012-02-08 16:37:41 -08005092 // the gap between the current output position and the proper start of
5093 // the next input sample is too big, so fill it with silence
5094 uint32_t framesUntilNextInput = (sampleDelta + 0x80000000) >> 32;
5095
John Grossman9fbdee12012-03-26 17:51:46 -07005096 timedYieldSilence_l(framesUntilNextInput, buffer);
John Grossman4ff14ba2012-02-08 16:37:41 -08005097 ALOGV("*** silence: frameCount=%u", buffer->frameCount);
5098 return NO_ERROR;
5099 } else {
5100 // the next input sample is late
5101 uint32_t lateFrames = static_cast<uint32_t>(-((sampleDelta + 0x80000000) >> 32));
5102 size_t onTimeSamplePosition =
5103 head.position() + lateFrames * mCblk->frameSize;
5104
5105 if (onTimeSamplePosition > head.buffer()->size()) {
5106 // all the remaining samples in the head are too late, so
5107 // drop it and move on
5108 ALOGV("*** too late: dropped buffer");
John Grossman1c345192012-03-27 14:00:17 -07005109 trimTimedBufferQueueHead_l("getNextBuffer, dropped late buffer");
John Grossman4ff14ba2012-02-08 16:37:41 -08005110 continue;
5111 } else {
5112 // skip over the late samples
5113 head.setPosition(onTimeSamplePosition);
5114
5115 // yield the available samples
John Grossman9fbdee12012-03-26 17:51:46 -07005116 timedYieldSamples_l(buffer);
John Grossman4ff14ba2012-02-08 16:37:41 -08005117
5118 ALOGV("*** late: head.pos=%d frameCount=%u", head.position(), buffer->frameCount);
5119 return NO_ERROR;
5120 }
5121 }
5122 }
5123}
5124
5125// Yield samples from the timed buffer queue head up to the given output
5126// buffer's capacity.
5127//
5128// Caller must hold mTimedBufferQueueLock
John Grossman9fbdee12012-03-26 17:51:46 -07005129void AudioFlinger::PlaybackThread::TimedTrack::timedYieldSamples_l(
John Grossman4ff14ba2012-02-08 16:37:41 -08005130 AudioBufferProvider::Buffer* buffer) {
5131
5132 const TimedBuffer& head = mTimedBufferQueue[0];
5133
5134 buffer->raw = (static_cast<uint8_t*>(head.buffer()->pointer()) +
5135 head.position());
5136
5137 uint32_t framesLeftInHead = ((head.buffer()->size() - head.position()) /
5138 mCblk->frameSize);
5139 size_t framesRequested = buffer->frameCount;
5140 buffer->frameCount = min(framesLeftInHead, framesRequested);
5141
John Grossman9fbdee12012-03-26 17:51:46 -07005142 mQueueHeadInFlight = true;
John Grossman4ff14ba2012-02-08 16:37:41 -08005143 mTimedAudioOutputOnTime = true;
5144}
5145
5146// Yield samples of silence up to the given output buffer's capacity
5147//
5148// Caller must hold mTimedBufferQueueLock
John Grossman9fbdee12012-03-26 17:51:46 -07005149void AudioFlinger::PlaybackThread::TimedTrack::timedYieldSilence_l(
John Grossman4ff14ba2012-02-08 16:37:41 -08005150 uint32_t numFrames, AudioBufferProvider::Buffer* buffer) {
5151
5152 // lazily allocate a buffer filled with silence
5153 if (mTimedSilenceBufferSize < numFrames * mCblk->frameSize) {
5154 delete [] mTimedSilenceBuffer;
5155 mTimedSilenceBufferSize = numFrames * mCblk->frameSize;
5156 mTimedSilenceBuffer = new uint8_t[mTimedSilenceBufferSize];
5157 memset(mTimedSilenceBuffer, 0, mTimedSilenceBufferSize);
5158 }
5159
5160 buffer->raw = mTimedSilenceBuffer;
5161 size_t framesRequested = buffer->frameCount;
5162 buffer->frameCount = min(numFrames, framesRequested);
5163
5164 mTimedAudioOutputOnTime = false;
5165}
5166
Glenn Kasten01c4ebf2012-02-22 10:47:35 -08005167// AudioBufferProvider interface
John Grossman4ff14ba2012-02-08 16:37:41 -08005168void AudioFlinger::PlaybackThread::TimedTrack::releaseBuffer(
5169 AudioBufferProvider::Buffer* buffer) {
5170
5171 Mutex::Autolock _l(mTimedBufferQueueLock);
5172
John Grossmanfe5b3ba2012-02-12 17:51:21 -08005173 // If the buffer which was just released is part of the buffer at the head
5174 // of the queue, be sure to update the amt of the buffer which has been
5175 // consumed. If the buffer being returned is not part of the head of the
5176 // queue, its either because the buffer is part of the silence buffer, or
5177 // because the head of the timed queue was trimmed after the mixer called
5178 // getNextBuffer but before the mixer called releaseBuffer.
John Grossman9fbdee12012-03-26 17:51:46 -07005179 if (buffer->raw == mTimedSilenceBuffer) {
5180 ALOG_ASSERT(!mQueueHeadInFlight,
5181 "Queue head in flight during release of silence buffer!");
5182 goto done;
5183 }
5184
5185 ALOG_ASSERT(mQueueHeadInFlight,
5186 "TimedTrack::releaseBuffer of non-silence buffer, but no queue"
5187 " head in flight.");
5188
5189 if (mTimedBufferQueue.size()) {
John Grossman4ff14ba2012-02-08 16:37:41 -08005190 TimedBuffer& head = mTimedBufferQueue.editItemAt(0);
John Grossmanfe5b3ba2012-02-12 17:51:21 -08005191
5192 void* start = head.buffer()->pointer();
John Grossman9fbdee12012-03-26 17:51:46 -07005193 void* end = reinterpret_cast<void*>(
5194 reinterpret_cast<uint8_t*>(head.buffer()->pointer())
5195 + head.buffer()->size());
John Grossmanfe5b3ba2012-02-12 17:51:21 -08005196
John Grossman9fbdee12012-03-26 17:51:46 -07005197 ALOG_ASSERT((buffer->raw >= start) && (buffer->raw < end),
5198 "released buffer not within the head of the timed buffer"
5199 " queue; qHead = [%p, %p], released buffer = %p",
5200 start, end, buffer->raw);
5201
5202 head.setPosition(head.position() +
5203 (buffer->frameCount * mCblk->frameSize));
5204 mQueueHeadInFlight = false;
5205
John Grossman1c345192012-03-27 14:00:17 -07005206 ALOG_ASSERT(mFramesPendingInQueue >= buffer->frameCount,
5207 "Bad bookkeeping during releaseBuffer! Should have at"
5208 " least %u queued frames, but we think we have only %u",
5209 buffer->frameCount, mFramesPendingInQueue);
5210
5211 mFramesPendingInQueue -= buffer->frameCount;
5212
John Grossman9fbdee12012-03-26 17:51:46 -07005213 if ((static_cast<size_t>(head.position()) >= head.buffer()->size())
5214 || mTrimQueueHeadOnRelease) {
John Grossman1c345192012-03-27 14:00:17 -07005215 trimTimedBufferQueueHead_l("releaseBuffer");
John Grossman9fbdee12012-03-26 17:51:46 -07005216 mTrimQueueHeadOnRelease = false;
John Grossman4ff14ba2012-02-08 16:37:41 -08005217 }
John Grossman9fbdee12012-03-26 17:51:46 -07005218 } else {
5219 LOG_FATAL("TimedTrack::releaseBuffer of non-silence buffer with no"
5220 " buffers in the timed buffer queue");
John Grossman4ff14ba2012-02-08 16:37:41 -08005221 }
5222
John Grossman9fbdee12012-03-26 17:51:46 -07005223done:
John Grossman4ff14ba2012-02-08 16:37:41 -08005224 buffer->raw = 0;
5225 buffer->frameCount = 0;
5226}
5227
Glenn Kasten288ed212012-04-25 17:52:27 -07005228size_t AudioFlinger::PlaybackThread::TimedTrack::framesReady() const {
John Grossman4ff14ba2012-02-08 16:37:41 -08005229 Mutex::Autolock _l(mTimedBufferQueueLock);
John Grossman1c345192012-03-27 14:00:17 -07005230 return mFramesPendingInQueue;
John Grossman4ff14ba2012-02-08 16:37:41 -08005231}
5232
5233AudioFlinger::PlaybackThread::TimedTrack::TimedBuffer::TimedBuffer()
5234 : mPTS(0), mPosition(0) {}
5235
5236AudioFlinger::PlaybackThread::TimedTrack::TimedBuffer::TimedBuffer(
5237 const sp<IMemory>& buffer, int64_t pts)
5238 : mBuffer(buffer), mPTS(pts), mPosition(0) {}
5239
Mathias Agopian65ab4712010-07-14 17:59:35 -07005240// ----------------------------------------------------------------------------
5241
5242// RecordTrack constructor must be called with AudioFlinger::mLock held
5243AudioFlinger::RecordThread::RecordTrack::RecordTrack(
Glenn Kasten9eaa5572012-01-20 13:32:16 -08005244 RecordThread *thread,
Mathias Agopian65ab4712010-07-14 17:59:35 -07005245 const sp<Client>& client,
5246 uint32_t sampleRate,
Glenn Kasten58f30212012-01-12 12:27:51 -08005247 audio_format_t format,
Jean-Michel Trivi0d255b22011-05-24 15:53:33 -07005248 uint32_t channelMask,
Mathias Agopian65ab4712010-07-14 17:59:35 -07005249 int frameCount,
Mathias Agopian65ab4712010-07-14 17:59:35 -07005250 int sessionId)
5251 : TrackBase(thread, client, sampleRate, format,
Glenn Kasten5cf034d2012-02-21 10:35:56 -08005252 channelMask, frameCount, 0 /*sharedBuffer*/, sessionId),
Mathias Agopian65ab4712010-07-14 17:59:35 -07005253 mOverflow(false)
5254{
5255 if (mCblk != NULL) {
Glenn Kastene53b9ea2012-03-12 16:29:55 -07005256 ALOGV("RecordTrack constructor, size %d", (int)mBufferEnd - (int)mBuffer);
5257 if (format == AUDIO_FORMAT_PCM_16_BIT) {
5258 mCblk->frameSize = mChannelCount * sizeof(int16_t);
5259 } else if (format == AUDIO_FORMAT_PCM_8_BIT) {
5260 mCblk->frameSize = mChannelCount * sizeof(int8_t);
5261 } else {
5262 mCblk->frameSize = sizeof(int8_t);
5263 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07005264 }
5265}
5266
5267AudioFlinger::RecordThread::RecordTrack::~RecordTrack()
5268{
5269 sp<ThreadBase> thread = mThread.promote();
5270 if (thread != 0) {
5271 AudioSystem::releaseInput(thread->id());
5272 }
5273}
5274
Glenn Kasten01c4ebf2012-02-22 10:47:35 -08005275// AudioBufferProvider interface
John Grossman4ff14ba2012-02-08 16:37:41 -08005276status_t AudioFlinger::RecordThread::RecordTrack::getNextBuffer(AudioBufferProvider::Buffer* buffer, int64_t pts)
Mathias Agopian65ab4712010-07-14 17:59:35 -07005277{
5278 audio_track_cblk_t* cblk = this->cblk();
5279 uint32_t framesAvail;
5280 uint32_t framesReq = buffer->frameCount;
5281
Glenn Kastene53b9ea2012-03-12 16:29:55 -07005282 // Check if last stepServer failed, try to step now
Glenn Kasten5cf034d2012-02-21 10:35:56 -08005283 if (mStepServerFailed) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07005284 if (!step()) goto getNextBuffer_exit;
Steve Block3856b092011-10-20 11:56:00 +01005285 ALOGV("stepServer recovered");
Glenn Kasten5cf034d2012-02-21 10:35:56 -08005286 mStepServerFailed = false;
Mathias Agopian65ab4712010-07-14 17:59:35 -07005287 }
5288
5289 framesAvail = cblk->framesAvailable_l();
5290
Glenn Kastenf6b16782011-12-15 09:51:17 -08005291 if (CC_LIKELY(framesAvail)) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07005292 uint32_t s = cblk->server;
5293 uint32_t bufferEnd = cblk->serverBase + cblk->frameCount;
5294
5295 if (framesReq > framesAvail) {
5296 framesReq = framesAvail;
5297 }
Marco Nelissena1472d92012-03-30 14:36:54 -07005298 if (framesReq > bufferEnd - s) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07005299 framesReq = bufferEnd - s;
5300 }
5301
5302 buffer->raw = getBuffer(s, framesReq);
Glenn Kastene0feee32011-12-13 11:53:26 -08005303 if (buffer->raw == NULL) goto getNextBuffer_exit;
Mathias Agopian65ab4712010-07-14 17:59:35 -07005304
5305 buffer->frameCount = framesReq;
5306 return NO_ERROR;
5307 }
5308
5309getNextBuffer_exit:
Glenn Kastene0feee32011-12-13 11:53:26 -08005310 buffer->raw = NULL;
Mathias Agopian65ab4712010-07-14 17:59:35 -07005311 buffer->frameCount = 0;
5312 return NOT_ENOUGH_DATA;
5313}
5314
Glenn Kasten3acbd052012-02-28 10:39:56 -08005315status_t AudioFlinger::RecordThread::RecordTrack::start(AudioSystem::sync_event_t event,
Eric Laurenta011e352012-03-29 15:51:43 -07005316 int triggerSession)
Mathias Agopian65ab4712010-07-14 17:59:35 -07005317{
5318 sp<ThreadBase> thread = mThread.promote();
5319 if (thread != 0) {
5320 RecordThread *recordThread = (RecordThread *)thread.get();
Glenn Kasten3acbd052012-02-28 10:39:56 -08005321 return recordThread->start(this, event, triggerSession);
Mathias Agopian65ab4712010-07-14 17:59:35 -07005322 } else {
5323 return BAD_VALUE;
5324 }
5325}
5326
5327void AudioFlinger::RecordThread::RecordTrack::stop()
5328{
5329 sp<ThreadBase> thread = mThread.promote();
5330 if (thread != 0) {
5331 RecordThread *recordThread = (RecordThread *)thread.get();
5332 recordThread->stop(this);
Eric Laurent38ccae22011-03-28 18:37:07 -07005333 TrackBase::reset();
Glenn Kasten17a736c2012-02-14 08:52:15 -08005334 // Force overrun condition to avoid false overrun callback until first data is
Eric Laurent38ccae22011-03-28 18:37:07 -07005335 // read from buffer
5336 android_atomic_or(CBLK_UNDERRUN_ON, &mCblk->flags);
Mathias Agopian65ab4712010-07-14 17:59:35 -07005337 }
5338}
5339
5340void AudioFlinger::RecordThread::RecordTrack::dump(char* buffer, size_t size)
5341{
Jean-Michel Trivi0d255b22011-05-24 15:53:33 -07005342 snprintf(buffer, size, " %05d %03u 0x%08x %05d %04u %01d %05u %08x %08x\n",
Glenn Kasten44deb052012-02-05 18:09:08 -08005343 (mClient == 0) ? getpid_cached : mClient->pid(),
Mathias Agopian65ab4712010-07-14 17:59:35 -07005344 mFormat,
Jean-Michel Trivi0d255b22011-05-24 15:53:33 -07005345 mChannelMask,
Mathias Agopian65ab4712010-07-14 17:59:35 -07005346 mSessionId,
5347 mFrameCount,
5348 mState,
5349 mCblk->sampleRate,
5350 mCblk->server,
5351 mCblk->user);
5352}
5353
5354
5355// ----------------------------------------------------------------------------
5356
5357AudioFlinger::PlaybackThread::OutputTrack::OutputTrack(
Glenn Kasten9eaa5572012-01-20 13:32:16 -08005358 PlaybackThread *playbackThread,
Mathias Agopian65ab4712010-07-14 17:59:35 -07005359 DuplicatingThread *sourceThread,
5360 uint32_t sampleRate,
Glenn Kasten58f30212012-01-12 12:27:51 -08005361 audio_format_t format,
Jean-Michel Trivi0d255b22011-05-24 15:53:33 -07005362 uint32_t channelMask,
Mathias Agopian65ab4712010-07-14 17:59:35 -07005363 int frameCount)
Glenn Kasten73d22752012-03-19 13:38:30 -07005364 : Track(playbackThread, NULL, AUDIO_STREAM_CNT, sampleRate, format, channelMask, frameCount,
5365 NULL, 0, IAudioFlinger::TRACK_DEFAULT),
Mathias Agopian65ab4712010-07-14 17:59:35 -07005366 mActive(false), mSourceThread(sourceThread)
5367{
5368
Mathias Agopian65ab4712010-07-14 17:59:35 -07005369 if (mCblk != NULL) {
5370 mCblk->flags |= CBLK_DIRECTION_OUT;
5371 mCblk->buffers = (char*)mCblk + sizeof(audio_track_cblk_t);
Mathias Agopian65ab4712010-07-14 17:59:35 -07005372 mOutBuffer.frameCount = 0;
5373 playbackThread->mTracks.add(this);
Steve Block3856b092011-10-20 11:56:00 +01005374 ALOGV("OutputTrack constructor mCblk %p, mBuffer %p, mCblk->buffers %p, " \
Jean-Michel Trivi0d255b22011-05-24 15:53:33 -07005375 "mCblk->frameCount %d, mCblk->sampleRate %d, mChannelMask 0x%08x mBufferEnd %p",
5376 mCblk, mBuffer, mCblk->buffers,
5377 mCblk->frameCount, mCblk->sampleRate, mChannelMask, mBufferEnd);
Mathias Agopian65ab4712010-07-14 17:59:35 -07005378 } else {
Steve Block5ff1dd52012-01-05 23:22:43 +00005379 ALOGW("Error creating output track on thread %p", playbackThread);
Mathias Agopian65ab4712010-07-14 17:59:35 -07005380 }
5381}
5382
5383AudioFlinger::PlaybackThread::OutputTrack::~OutputTrack()
5384{
5385 clearBufferQueue();
5386}
5387
Glenn Kasten3acbd052012-02-28 10:39:56 -08005388status_t AudioFlinger::PlaybackThread::OutputTrack::start(AudioSystem::sync_event_t event,
Eric Laurenta011e352012-03-29 15:51:43 -07005389 int triggerSession)
Mathias Agopian65ab4712010-07-14 17:59:35 -07005390{
Glenn Kasten3acbd052012-02-28 10:39:56 -08005391 status_t status = Track::start(event, triggerSession);
Mathias Agopian65ab4712010-07-14 17:59:35 -07005392 if (status != NO_ERROR) {
5393 return status;
5394 }
5395
5396 mActive = true;
5397 mRetryCount = 127;
5398 return status;
5399}
5400
5401void AudioFlinger::PlaybackThread::OutputTrack::stop()
5402{
5403 Track::stop();
5404 clearBufferQueue();
5405 mOutBuffer.frameCount = 0;
5406 mActive = false;
5407}
5408
5409bool AudioFlinger::PlaybackThread::OutputTrack::write(int16_t* data, uint32_t frames)
5410{
5411 Buffer *pInBuffer;
5412 Buffer inBuffer;
Jean-Michel Trivi0d255b22011-05-24 15:53:33 -07005413 uint32_t channelCount = mChannelCount;
Mathias Agopian65ab4712010-07-14 17:59:35 -07005414 bool outputBufferFull = false;
5415 inBuffer.frameCount = frames;
5416 inBuffer.i16 = data;
5417
5418 uint32_t waitTimeLeftMs = mSourceThread->waitTimeMs();
5419
5420 if (!mActive && frames != 0) {
Glenn Kasten3acbd052012-02-28 10:39:56 -08005421 start();
Mathias Agopian65ab4712010-07-14 17:59:35 -07005422 sp<ThreadBase> thread = mThread.promote();
5423 if (thread != 0) {
5424 MixerThread *mixerThread = (MixerThread *)thread.get();
5425 if (mCblk->frameCount > frames){
5426 if (mBufferQueue.size() < kMaxOverFlowBuffers) {
5427 uint32_t startFrames = (mCblk->frameCount - frames);
5428 pInBuffer = new Buffer;
5429 pInBuffer->mBuffer = new int16_t[startFrames * channelCount];
5430 pInBuffer->frameCount = startFrames;
5431 pInBuffer->i16 = pInBuffer->mBuffer;
5432 memset(pInBuffer->raw, 0, startFrames * channelCount * sizeof(int16_t));
5433 mBufferQueue.add(pInBuffer);
5434 } else {
Steve Block5ff1dd52012-01-05 23:22:43 +00005435 ALOGW ("OutputTrack::write() %p no more buffers in queue", this);
Mathias Agopian65ab4712010-07-14 17:59:35 -07005436 }
5437 }
5438 }
5439 }
5440
5441 while (waitTimeLeftMs) {
5442 // First write pending buffers, then new data
5443 if (mBufferQueue.size()) {
5444 pInBuffer = mBufferQueue.itemAt(0);
5445 } else {
5446 pInBuffer = &inBuffer;
5447 }
5448
5449 if (pInBuffer->frameCount == 0) {
5450 break;
5451 }
5452
5453 if (mOutBuffer.frameCount == 0) {
5454 mOutBuffer.frameCount = pInBuffer->frameCount;
5455 nsecs_t startTime = systemTime();
Glenn Kasten335787f2012-01-20 17:00:00 -08005456 if (obtainBuffer(&mOutBuffer, waitTimeLeftMs) == (status_t)NO_MORE_BUFFERS) {
Steve Block3856b092011-10-20 11:56:00 +01005457 ALOGV ("OutputTrack::write() %p thread %p no more output buffers", this, mThread.unsafe_get());
Mathias Agopian65ab4712010-07-14 17:59:35 -07005458 outputBufferFull = true;
5459 break;
5460 }
5461 uint32_t waitTimeMs = (uint32_t)ns2ms(systemTime() - startTime);
5462 if (waitTimeLeftMs >= waitTimeMs) {
5463 waitTimeLeftMs -= waitTimeMs;
5464 } else {
5465 waitTimeLeftMs = 0;
5466 }
5467 }
5468
5469 uint32_t outFrames = pInBuffer->frameCount > mOutBuffer.frameCount ? mOutBuffer.frameCount : pInBuffer->frameCount;
5470 memcpy(mOutBuffer.raw, pInBuffer->raw, outFrames * channelCount * sizeof(int16_t));
5471 mCblk->stepUser(outFrames);
5472 pInBuffer->frameCount -= outFrames;
5473 pInBuffer->i16 += outFrames * channelCount;
5474 mOutBuffer.frameCount -= outFrames;
5475 mOutBuffer.i16 += outFrames * channelCount;
5476
5477 if (pInBuffer->frameCount == 0) {
5478 if (mBufferQueue.size()) {
5479 mBufferQueue.removeAt(0);
5480 delete [] pInBuffer->mBuffer;
5481 delete pInBuffer;
Steve Block3856b092011-10-20 11:56:00 +01005482 ALOGV("OutputTrack::write() %p thread %p released overflow buffer %d", this, mThread.unsafe_get(), mBufferQueue.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07005483 } else {
5484 break;
5485 }
5486 }
5487 }
5488
5489 // If we could not write all frames, allocate a buffer and queue it for next time.
5490 if (inBuffer.frameCount) {
5491 sp<ThreadBase> thread = mThread.promote();
5492 if (thread != 0 && !thread->standby()) {
5493 if (mBufferQueue.size() < kMaxOverFlowBuffers) {
5494 pInBuffer = new Buffer;
5495 pInBuffer->mBuffer = new int16_t[inBuffer.frameCount * channelCount];
5496 pInBuffer->frameCount = inBuffer.frameCount;
5497 pInBuffer->i16 = pInBuffer->mBuffer;
5498 memcpy(pInBuffer->raw, inBuffer.raw, inBuffer.frameCount * channelCount * sizeof(int16_t));
5499 mBufferQueue.add(pInBuffer);
Steve Block3856b092011-10-20 11:56:00 +01005500 ALOGV("OutputTrack::write() %p thread %p adding overflow buffer %d", this, mThread.unsafe_get(), mBufferQueue.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07005501 } else {
Steve Block5ff1dd52012-01-05 23:22:43 +00005502 ALOGW("OutputTrack::write() %p thread %p no more overflow buffers", mThread.unsafe_get(), this);
Mathias Agopian65ab4712010-07-14 17:59:35 -07005503 }
5504 }
5505 }
5506
5507 // Calling write() with a 0 length buffer, means that no more data will be written:
5508 // If no more buffers are pending, fill output track buffer to make sure it is started
5509 // by output mixer.
5510 if (frames == 0 && mBufferQueue.size() == 0) {
5511 if (mCblk->user < mCblk->frameCount) {
5512 frames = mCblk->frameCount - mCblk->user;
5513 pInBuffer = new Buffer;
5514 pInBuffer->mBuffer = new int16_t[frames * channelCount];
5515 pInBuffer->frameCount = frames;
5516 pInBuffer->i16 = pInBuffer->mBuffer;
5517 memset(pInBuffer->raw, 0, frames * channelCount * sizeof(int16_t));
5518 mBufferQueue.add(pInBuffer);
5519 } else if (mActive) {
5520 stop();
5521 }
5522 }
5523
5524 return outputBufferFull;
5525}
5526
5527status_t AudioFlinger::PlaybackThread::OutputTrack::obtainBuffer(AudioBufferProvider::Buffer* buffer, uint32_t waitTimeMs)
5528{
5529 int active;
5530 status_t result;
5531 audio_track_cblk_t* cblk = mCblk;
5532 uint32_t framesReq = buffer->frameCount;
5533
Steve Block3856b092011-10-20 11:56:00 +01005534// ALOGV("OutputTrack::obtainBuffer user %d, server %d", cblk->user, cblk->server);
Mathias Agopian65ab4712010-07-14 17:59:35 -07005535 buffer->frameCount = 0;
5536
5537 uint32_t framesAvail = cblk->framesAvailable();
5538
5539
5540 if (framesAvail == 0) {
5541 Mutex::Autolock _l(cblk->lock);
5542 goto start_loop_here;
5543 while (framesAvail == 0) {
5544 active = mActive;
Glenn Kastenf6b16782011-12-15 09:51:17 -08005545 if (CC_UNLIKELY(!active)) {
Steve Block3856b092011-10-20 11:56:00 +01005546 ALOGV("Not active and NO_MORE_BUFFERS");
Glenn Kasten335787f2012-01-20 17:00:00 -08005547 return NO_MORE_BUFFERS;
Mathias Agopian65ab4712010-07-14 17:59:35 -07005548 }
5549 result = cblk->cv.waitRelative(cblk->lock, milliseconds(waitTimeMs));
5550 if (result != NO_ERROR) {
Glenn Kasten335787f2012-01-20 17:00:00 -08005551 return NO_MORE_BUFFERS;
Mathias Agopian65ab4712010-07-14 17:59:35 -07005552 }
5553 // read the server count again
5554 start_loop_here:
5555 framesAvail = cblk->framesAvailable_l();
5556 }
5557 }
5558
5559// if (framesAvail < framesReq) {
Glenn Kasten335787f2012-01-20 17:00:00 -08005560// return NO_MORE_BUFFERS;
Mathias Agopian65ab4712010-07-14 17:59:35 -07005561// }
5562
5563 if (framesReq > framesAvail) {
5564 framesReq = framesAvail;
5565 }
5566
5567 uint32_t u = cblk->user;
5568 uint32_t bufferEnd = cblk->userBase + cblk->frameCount;
5569
Marco Nelissena1472d92012-03-30 14:36:54 -07005570 if (framesReq > bufferEnd - u) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07005571 framesReq = bufferEnd - u;
5572 }
5573
5574 buffer->frameCount = framesReq;
5575 buffer->raw = (void *)cblk->buffer(u);
5576 return NO_ERROR;
5577}
5578
5579
5580void AudioFlinger::PlaybackThread::OutputTrack::clearBufferQueue()
5581{
5582 size_t size = mBufferQueue.size();
Mathias Agopian65ab4712010-07-14 17:59:35 -07005583
5584 for (size_t i = 0; i < size; i++) {
Glenn Kastena1117922012-01-26 10:53:32 -08005585 Buffer *pBuffer = mBufferQueue.itemAt(i);
Mathias Agopian65ab4712010-07-14 17:59:35 -07005586 delete [] pBuffer->mBuffer;
5587 delete pBuffer;
5588 }
5589 mBufferQueue.clear();
5590}
5591
5592// ----------------------------------------------------------------------------
5593
5594AudioFlinger::Client::Client(const sp<AudioFlinger>& audioFlinger, pid_t pid)
5595 : RefBase(),
5596 mAudioFlinger(audioFlinger),
Glenn Kasten99e53b82012-01-19 08:59:58 -08005597 // FIXME should be a "k" constant not hard-coded, in .h or ro. property, see 4 lines below
Mathias Agopian65ab4712010-07-14 17:59:35 -07005598 mMemoryDealer(new MemoryDealer(1024*1024, "AudioFlinger::Client")),
John Grossman4ff14ba2012-02-08 16:37:41 -08005599 mPid(pid),
5600 mTimedTrackCount(0)
Mathias Agopian65ab4712010-07-14 17:59:35 -07005601{
5602 // 1 MB of address space is good for 32 tracks, 8 buffers each, 4 KB/buffer
5603}
5604
5605// Client destructor must be called with AudioFlinger::mLock held
5606AudioFlinger::Client::~Client()
5607{
5608 mAudioFlinger->removeClient_l(mPid);
5609}
5610
Glenn Kasten435dbe62012-01-30 10:15:48 -08005611sp<MemoryDealer> AudioFlinger::Client::heap() const
Mathias Agopian65ab4712010-07-14 17:59:35 -07005612{
5613 return mMemoryDealer;
5614}
5615
John Grossman4ff14ba2012-02-08 16:37:41 -08005616// Reserve one of the limited slots for a timed audio track associated
5617// with this client
5618bool AudioFlinger::Client::reserveTimedTrack()
5619{
5620 const int kMaxTimedTracksPerClient = 4;
5621
5622 Mutex::Autolock _l(mTimedTrackLock);
5623
5624 if (mTimedTrackCount >= kMaxTimedTracksPerClient) {
5625 ALOGW("can not create timed track - pid %d has exceeded the limit",
5626 mPid);
5627 return false;
5628 }
5629
5630 mTimedTrackCount++;
5631 return true;
5632}
5633
5634// Release a slot for a timed audio track
5635void AudioFlinger::Client::releaseTimedTrack()
5636{
5637 Mutex::Autolock _l(mTimedTrackLock);
5638 mTimedTrackCount--;
5639}
5640
Mathias Agopian65ab4712010-07-14 17:59:35 -07005641// ----------------------------------------------------------------------------
5642
5643AudioFlinger::NotificationClient::NotificationClient(const sp<AudioFlinger>& audioFlinger,
5644 const sp<IAudioFlingerClient>& client,
5645 pid_t pid)
Glenn Kasten84afa3b2012-01-25 15:28:08 -08005646 : mAudioFlinger(audioFlinger), mPid(pid), mAudioFlingerClient(client)
Mathias Agopian65ab4712010-07-14 17:59:35 -07005647{
5648}
5649
5650AudioFlinger::NotificationClient::~NotificationClient()
5651{
Mathias Agopian65ab4712010-07-14 17:59:35 -07005652}
5653
5654void AudioFlinger::NotificationClient::binderDied(const wp<IBinder>& who)
5655{
5656 sp<NotificationClient> keep(this);
Glenn Kastena1117922012-01-26 10:53:32 -08005657 mAudioFlinger->removeNotificationClient(mPid);
Mathias Agopian65ab4712010-07-14 17:59:35 -07005658}
5659
5660// ----------------------------------------------------------------------------
5661
5662AudioFlinger::TrackHandle::TrackHandle(const sp<AudioFlinger::PlaybackThread::Track>& track)
5663 : BnAudioTrack(),
5664 mTrack(track)
5665{
5666}
5667
5668AudioFlinger::TrackHandle::~TrackHandle() {
5669 // just stop the track on deletion, associated resources
5670 // will be freed from the main thread once all pending buffers have
5671 // been played. Unless it's not in the active track list, in which
5672 // case we free everything now...
5673 mTrack->destroy();
5674}
5675
Glenn Kasten90716c52012-01-26 13:40:12 -08005676sp<IMemory> AudioFlinger::TrackHandle::getCblk() const {
5677 return mTrack->getCblk();
5678}
5679
Glenn Kasten3acbd052012-02-28 10:39:56 -08005680status_t AudioFlinger::TrackHandle::start() {
5681 return mTrack->start();
Mathias Agopian65ab4712010-07-14 17:59:35 -07005682}
5683
5684void AudioFlinger::TrackHandle::stop() {
5685 mTrack->stop();
5686}
5687
5688void AudioFlinger::TrackHandle::flush() {
5689 mTrack->flush();
5690}
5691
5692void AudioFlinger::TrackHandle::mute(bool e) {
5693 mTrack->mute(e);
5694}
5695
5696void AudioFlinger::TrackHandle::pause() {
5697 mTrack->pause();
5698}
5699
Mathias Agopian65ab4712010-07-14 17:59:35 -07005700status_t AudioFlinger::TrackHandle::attachAuxEffect(int EffectId)
5701{
5702 return mTrack->attachAuxEffect(EffectId);
5703}
5704
John Grossman4ff14ba2012-02-08 16:37:41 -08005705status_t AudioFlinger::TrackHandle::allocateTimedBuffer(size_t size,
5706 sp<IMemory>* buffer) {
5707 if (!mTrack->isTimedTrack())
5708 return INVALID_OPERATION;
5709
5710 PlaybackThread::TimedTrack* tt =
5711 reinterpret_cast<PlaybackThread::TimedTrack*>(mTrack.get());
5712 return tt->allocateTimedBuffer(size, buffer);
5713}
5714
5715status_t AudioFlinger::TrackHandle::queueTimedBuffer(const sp<IMemory>& buffer,
5716 int64_t pts) {
5717 if (!mTrack->isTimedTrack())
5718 return INVALID_OPERATION;
5719
5720 PlaybackThread::TimedTrack* tt =
5721 reinterpret_cast<PlaybackThread::TimedTrack*>(mTrack.get());
5722 return tt->queueTimedBuffer(buffer, pts);
5723}
5724
5725status_t AudioFlinger::TrackHandle::setMediaTimeTransform(
5726 const LinearTransform& xform, int target) {
5727
5728 if (!mTrack->isTimedTrack())
5729 return INVALID_OPERATION;
5730
5731 PlaybackThread::TimedTrack* tt =
5732 reinterpret_cast<PlaybackThread::TimedTrack*>(mTrack.get());
5733 return tt->setMediaTimeTransform(
5734 xform, static_cast<TimedAudioTrack::TargetTimeline>(target));
5735}
5736
Mathias Agopian65ab4712010-07-14 17:59:35 -07005737status_t AudioFlinger::TrackHandle::onTransact(
5738 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
5739{
5740 return BnAudioTrack::onTransact(code, data, reply, flags);
5741}
5742
5743// ----------------------------------------------------------------------------
5744
5745sp<IAudioRecord> AudioFlinger::openRecord(
5746 pid_t pid,
Glenn Kasten72ef00d2012-01-17 11:09:42 -08005747 audio_io_handle_t input,
Mathias Agopian65ab4712010-07-14 17:59:35 -07005748 uint32_t sampleRate,
Glenn Kasten58f30212012-01-12 12:27:51 -08005749 audio_format_t format,
Jean-Michel Trivi0d255b22011-05-24 15:53:33 -07005750 uint32_t channelMask,
Mathias Agopian65ab4712010-07-14 17:59:35 -07005751 int frameCount,
Glenn Kastena075db42012-03-06 11:22:44 -08005752 IAudioFlinger::track_flags_t flags,
Mathias Agopian65ab4712010-07-14 17:59:35 -07005753 int *sessionId,
5754 status_t *status)
5755{
5756 sp<RecordThread::RecordTrack> recordTrack;
5757 sp<RecordHandle> recordHandle;
5758 sp<Client> client;
Mathias Agopian65ab4712010-07-14 17:59:35 -07005759 status_t lStatus;
5760 RecordThread *thread;
5761 size_t inFrameCount;
5762 int lSessionId;
5763
5764 // check calling permissions
5765 if (!recordingAllowed()) {
5766 lStatus = PERMISSION_DENIED;
5767 goto Exit;
5768 }
5769
5770 // add client to list
5771 { // scope for mLock
5772 Mutex::Autolock _l(mLock);
5773 thread = checkRecordThread_l(input);
5774 if (thread == NULL) {
5775 lStatus = BAD_VALUE;
5776 goto Exit;
5777 }
5778
Glenn Kasten98ec94c2012-01-25 14:28:29 -08005779 client = registerPid_l(pid);
Mathias Agopian65ab4712010-07-14 17:59:35 -07005780
5781 // If no audio session id is provided, create one here
Dima Zavinfce7a472011-04-19 22:30:36 -07005782 if (sessionId != NULL && *sessionId != AUDIO_SESSION_OUTPUT_MIX) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07005783 lSessionId = *sessionId;
5784 } else {
Eric Laurent7c7f10b2011-06-17 21:29:58 -07005785 lSessionId = nextUniqueId();
Mathias Agopian65ab4712010-07-14 17:59:35 -07005786 if (sessionId != NULL) {
5787 *sessionId = lSessionId;
5788 }
5789 }
5790 // create new record track. The record track uses one track in mHardwareMixerThread by convention.
Eric Laurent7c7f10b2011-06-17 21:29:58 -07005791 recordTrack = thread->createRecordTrack_l(client,
5792 sampleRate,
5793 format,
5794 channelMask,
5795 frameCount,
Eric Laurent7c7f10b2011-06-17 21:29:58 -07005796 lSessionId,
5797 &lStatus);
Mathias Agopian65ab4712010-07-14 17:59:35 -07005798 }
Eric Laurent7c7f10b2011-06-17 21:29:58 -07005799 if (lStatus != NO_ERROR) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07005800 // remove local strong reference to Client before deleting the RecordTrack so that the Client
5801 // destructor is called by the TrackBase destructor with mLock held
5802 client.clear();
5803 recordTrack.clear();
Mathias Agopian65ab4712010-07-14 17:59:35 -07005804 goto Exit;
5805 }
5806
5807 // return to handle to client
5808 recordHandle = new RecordHandle(recordTrack);
5809 lStatus = NO_ERROR;
5810
5811Exit:
5812 if (status) {
5813 *status = lStatus;
5814 }
5815 return recordHandle;
5816}
5817
5818// ----------------------------------------------------------------------------
5819
5820AudioFlinger::RecordHandle::RecordHandle(const sp<AudioFlinger::RecordThread::RecordTrack>& recordTrack)
5821 : BnAudioRecord(),
5822 mRecordTrack(recordTrack)
5823{
5824}
5825
5826AudioFlinger::RecordHandle::~RecordHandle() {
5827 stop();
5828}
5829
Glenn Kasten90716c52012-01-26 13:40:12 -08005830sp<IMemory> AudioFlinger::RecordHandle::getCblk() const {
5831 return mRecordTrack->getCblk();
5832}
5833
Glenn Kasten3acbd052012-02-28 10:39:56 -08005834status_t AudioFlinger::RecordHandle::start(int event, int triggerSession) {
Steve Block3856b092011-10-20 11:56:00 +01005835 ALOGV("RecordHandle::start()");
Glenn Kasten3acbd052012-02-28 10:39:56 -08005836 return mRecordTrack->start((AudioSystem::sync_event_t)event, triggerSession);
Mathias Agopian65ab4712010-07-14 17:59:35 -07005837}
5838
5839void AudioFlinger::RecordHandle::stop() {
Steve Block3856b092011-10-20 11:56:00 +01005840 ALOGV("RecordHandle::stop()");
Mathias Agopian65ab4712010-07-14 17:59:35 -07005841 mRecordTrack->stop();
5842}
5843
Mathias Agopian65ab4712010-07-14 17:59:35 -07005844status_t AudioFlinger::RecordHandle::onTransact(
5845 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
5846{
5847 return BnAudioRecord::onTransact(code, data, reply, flags);
5848}
5849
5850// ----------------------------------------------------------------------------
5851
Eric Laurent7c7f10b2011-06-17 21:29:58 -07005852AudioFlinger::RecordThread::RecordThread(const sp<AudioFlinger>& audioFlinger,
5853 AudioStreamIn *input,
5854 uint32_t sampleRate,
5855 uint32_t channels,
Glenn Kasten72ef00d2012-01-17 11:09:42 -08005856 audio_io_handle_t id,
Eric Laurent7c7f10b2011-06-17 21:29:58 -07005857 uint32_t device) :
Glenn Kasten23bb8be2012-01-26 10:38:26 -08005858 ThreadBase(audioFlinger, id, device, RECORD),
Glenn Kasten84afa3b2012-01-25 15:28:08 -08005859 mInput(input), mTrack(NULL), mResampler(NULL), mRsmpOutBuffer(NULL), mRsmpInBuffer(NULL),
5860 // mRsmpInIndex and mInputBytes set by readInputParameters()
5861 mReqChannelCount(popcount(channels)),
5862 mReqSampleRate(sampleRate)
5863 // mBytesRead is only meaningful while active, and so is cleared in start()
5864 // (but might be better to also clear here for dump?)
Mathias Agopian65ab4712010-07-14 17:59:35 -07005865{
Glenn Kasten480b4682012-02-28 12:30:08 -08005866 snprintf(mName, kNameLength, "AudioIn_%X", id);
Eric Laurentfeb0db62011-07-22 09:04:31 -07005867
Mathias Agopian65ab4712010-07-14 17:59:35 -07005868 readInputParameters();
5869}
5870
5871
5872AudioFlinger::RecordThread::~RecordThread()
5873{
5874 delete[] mRsmpInBuffer;
Glenn Kastene9dd0172012-01-27 18:08:45 -08005875 delete mResampler;
5876 delete[] mRsmpOutBuffer;
Mathias Agopian65ab4712010-07-14 17:59:35 -07005877}
5878
5879void AudioFlinger::RecordThread::onFirstRef()
5880{
Eric Laurentfeb0db62011-07-22 09:04:31 -07005881 run(mName, PRIORITY_URGENT_AUDIO);
Mathias Agopian65ab4712010-07-14 17:59:35 -07005882}
5883
Eric Laurentb8ba0a92011-08-07 16:32:26 -07005884status_t AudioFlinger::RecordThread::readyToRun()
5885{
5886 status_t status = initCheck();
Steve Block5ff1dd52012-01-05 23:22:43 +00005887 ALOGW_IF(status != NO_ERROR,"RecordThread %p could not initialize", this);
Eric Laurentb8ba0a92011-08-07 16:32:26 -07005888 return status;
5889}
5890
Mathias Agopian65ab4712010-07-14 17:59:35 -07005891bool AudioFlinger::RecordThread::threadLoop()
5892{
5893 AudioBufferProvider::Buffer buffer;
5894 sp<RecordTrack> activeTrack;
Eric Laurent7c7f10b2011-06-17 21:29:58 -07005895 Vector< sp<EffectChain> > effectChains;
Mathias Agopian65ab4712010-07-14 17:59:35 -07005896
Eric Laurent44d98482010-09-30 16:12:31 -07005897 nsecs_t lastWarning = 0;
5898
Eric Laurentfeb0db62011-07-22 09:04:31 -07005899 acquireWakeLock();
5900
Mathias Agopian65ab4712010-07-14 17:59:35 -07005901 // start recording
5902 while (!exitPending()) {
5903
5904 processConfigEvents();
5905
5906 { // scope for mLock
5907 Mutex::Autolock _l(mLock);
5908 checkForNewParameters_l();
5909 if (mActiveTrack == 0 && mConfigEvents.isEmpty()) {
5910 if (!mStandby) {
Dima Zavin799a70e2011-04-18 16:57:27 -07005911 mInput->stream->common.standby(&mInput->stream->common);
Mathias Agopian65ab4712010-07-14 17:59:35 -07005912 mStandby = true;
5913 }
5914
5915 if (exitPending()) break;
5916
Eric Laurentfeb0db62011-07-22 09:04:31 -07005917 releaseWakeLock_l();
Steve Block3856b092011-10-20 11:56:00 +01005918 ALOGV("RecordThread: loop stopping");
Mathias Agopian65ab4712010-07-14 17:59:35 -07005919 // go to sleep
5920 mWaitWorkCV.wait(mLock);
Steve Block3856b092011-10-20 11:56:00 +01005921 ALOGV("RecordThread: loop starting");
Eric Laurentfeb0db62011-07-22 09:04:31 -07005922 acquireWakeLock_l();
Mathias Agopian65ab4712010-07-14 17:59:35 -07005923 continue;
5924 }
5925 if (mActiveTrack != 0) {
5926 if (mActiveTrack->mState == TrackBase::PAUSING) {
5927 if (!mStandby) {
Dima Zavin799a70e2011-04-18 16:57:27 -07005928 mInput->stream->common.standby(&mInput->stream->common);
Mathias Agopian65ab4712010-07-14 17:59:35 -07005929 mStandby = true;
5930 }
5931 mActiveTrack.clear();
5932 mStartStopCond.broadcast();
5933 } else if (mActiveTrack->mState == TrackBase::RESUMING) {
5934 if (mReqChannelCount != mActiveTrack->channelCount()) {
5935 mActiveTrack.clear();
5936 mStartStopCond.broadcast();
5937 } else if (mBytesRead != 0) {
5938 // record start succeeds only if first read from audio input
5939 // succeeds
5940 if (mBytesRead > 0) {
5941 mActiveTrack->mState = TrackBase::ACTIVE;
5942 } else {
5943 mActiveTrack.clear();
5944 }
5945 mStartStopCond.broadcast();
5946 }
5947 mStandby = false;
5948 }
5949 }
Eric Laurent7c7f10b2011-06-17 21:29:58 -07005950 lockEffectChains_l(effectChains);
Mathias Agopian65ab4712010-07-14 17:59:35 -07005951 }
5952
5953 if (mActiveTrack != 0) {
5954 if (mActiveTrack->mState != TrackBase::ACTIVE &&
5955 mActiveTrack->mState != TrackBase::RESUMING) {
Eric Laurent7c7f10b2011-06-17 21:29:58 -07005956 unlockEffectChains(effectChains);
5957 usleep(kRecordThreadSleepUs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07005958 continue;
5959 }
Eric Laurent7c7f10b2011-06-17 21:29:58 -07005960 for (size_t i = 0; i < effectChains.size(); i ++) {
5961 effectChains[i]->process_l();
5962 }
Eric Laurent7c7f10b2011-06-17 21:29:58 -07005963
Mathias Agopian65ab4712010-07-14 17:59:35 -07005964 buffer.frameCount = mFrameCount;
Glenn Kasten01c4ebf2012-02-22 10:47:35 -08005965 if (CC_LIKELY(mActiveTrack->getNextBuffer(&buffer) == NO_ERROR)) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07005966 size_t framesOut = buffer.frameCount;
Glenn Kastene0feee32011-12-13 11:53:26 -08005967 if (mResampler == NULL) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07005968 // no resampling
5969 while (framesOut) {
5970 size_t framesIn = mFrameCount - mRsmpInIndex;
5971 if (framesIn) {
5972 int8_t *src = (int8_t *)mRsmpInBuffer + mRsmpInIndex * mFrameSize;
5973 int8_t *dst = buffer.i8 + (buffer.frameCount - framesOut) * mActiveTrack->mCblk->frameSize;
5974 if (framesIn > framesOut)
5975 framesIn = framesOut;
5976 mRsmpInIndex += framesIn;
5977 framesOut -= framesIn;
5978 if ((int)mChannelCount == mReqChannelCount ||
Dima Zavinfce7a472011-04-19 22:30:36 -07005979 mFormat != AUDIO_FORMAT_PCM_16_BIT) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07005980 memcpy(dst, src, framesIn * mFrameSize);
5981 } else {
5982 int16_t *src16 = (int16_t *)src;
5983 int16_t *dst16 = (int16_t *)dst;
5984 if (mChannelCount == 1) {
5985 while (framesIn--) {
5986 *dst16++ = *src16;
5987 *dst16++ = *src16++;
5988 }
5989 } else {
5990 while (framesIn--) {
5991 *dst16++ = (int16_t)(((int32_t)*src16 + (int32_t)*(src16 + 1)) >> 1);
5992 src16 += 2;
5993 }
5994 }
5995 }
5996 }
5997 if (framesOut && mFrameCount == mRsmpInIndex) {
5998 if (framesOut == mFrameCount &&
Dima Zavinfce7a472011-04-19 22:30:36 -07005999 ((int)mChannelCount == mReqChannelCount || mFormat != AUDIO_FORMAT_PCM_16_BIT)) {
Dima Zavin799a70e2011-04-18 16:57:27 -07006000 mBytesRead = mInput->stream->read(mInput->stream, buffer.raw, mInputBytes);
Mathias Agopian65ab4712010-07-14 17:59:35 -07006001 framesOut = 0;
6002 } else {
Dima Zavin799a70e2011-04-18 16:57:27 -07006003 mBytesRead = mInput->stream->read(mInput->stream, mRsmpInBuffer, mInputBytes);
Mathias Agopian65ab4712010-07-14 17:59:35 -07006004 mRsmpInIndex = 0;
6005 }
6006 if (mBytesRead < 0) {
Steve Block29357bc2012-01-06 19:20:56 +00006007 ALOGE("Error reading audio input");
Mathias Agopian65ab4712010-07-14 17:59:35 -07006008 if (mActiveTrack->mState == TrackBase::ACTIVE) {
6009 // Force input into standby so that it tries to
6010 // recover at next read attempt
Dima Zavin799a70e2011-04-18 16:57:27 -07006011 mInput->stream->common.standby(&mInput->stream->common);
Eric Laurent7c7f10b2011-06-17 21:29:58 -07006012 usleep(kRecordThreadSleepUs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07006013 }
6014 mRsmpInIndex = mFrameCount;
6015 framesOut = 0;
6016 buffer.frameCount = 0;
6017 }
6018 }
6019 }
6020 } else {
6021 // resampling
6022
6023 memset(mRsmpOutBuffer, 0, framesOut * 2 * sizeof(int32_t));
6024 // alter output frame count as if we were expecting stereo samples
6025 if (mChannelCount == 1 && mReqChannelCount == 1) {
6026 framesOut >>= 1;
6027 }
6028 mResampler->resample(mRsmpOutBuffer, framesOut, this);
6029 // ditherAndClamp() works as long as all buffers returned by mActiveTrack->getNextBuffer()
6030 // are 32 bit aligned which should be always true.
6031 if (mChannelCount == 2 && mReqChannelCount == 1) {
Glenn Kasten3b21c502011-12-15 09:52:39 -08006032 ditherAndClamp(mRsmpOutBuffer, mRsmpOutBuffer, framesOut);
Mathias Agopian65ab4712010-07-14 17:59:35 -07006033 // the resampler always outputs stereo samples: do post stereo to mono conversion
6034 int16_t *src = (int16_t *)mRsmpOutBuffer;
6035 int16_t *dst = buffer.i16;
6036 while (framesOut--) {
6037 *dst++ = (int16_t)(((int32_t)*src + (int32_t)*(src + 1)) >> 1);
6038 src += 2;
6039 }
6040 } else {
Glenn Kasten3b21c502011-12-15 09:52:39 -08006041 ditherAndClamp((int32_t *)buffer.raw, mRsmpOutBuffer, framesOut);
Mathias Agopian65ab4712010-07-14 17:59:35 -07006042 }
6043
6044 }
Eric Laurenta011e352012-03-29 15:51:43 -07006045 if (mFramestoDrop == 0) {
6046 mActiveTrack->releaseBuffer(&buffer);
6047 } else {
6048 if (mFramestoDrop > 0) {
6049 mFramestoDrop -= buffer.frameCount;
Eric Laurent29864602012-05-08 18:57:51 -07006050 if (mFramestoDrop <= 0) {
6051 clearSyncStartEvent();
6052 }
6053 } else {
6054 mFramestoDrop += buffer.frameCount;
6055 if (mFramestoDrop >= 0 || mSyncStartEvent == 0 ||
6056 mSyncStartEvent->isCancelled()) {
6057 ALOGW("Synced record %s, session %d, trigger session %d",
6058 (mFramestoDrop >= 0) ? "timed out" : "cancelled",
6059 mActiveTrack->sessionId(),
6060 (mSyncStartEvent != 0) ? mSyncStartEvent->triggerSession() : 0);
6061 clearSyncStartEvent();
Eric Laurenta011e352012-03-29 15:51:43 -07006062 }
6063 }
6064 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07006065 mActiveTrack->overflow();
6066 }
6067 // client isn't retrieving buffers fast enough
6068 else {
Eric Laurent44d98482010-09-30 16:12:31 -07006069 if (!mActiveTrack->setOverflow()) {
6070 nsecs_t now = systemTime();
Glenn Kasten7dede872011-12-13 11:04:14 -08006071 if ((now - lastWarning) > kWarningThrottleNs) {
Steve Block5ff1dd52012-01-05 23:22:43 +00006072 ALOGW("RecordThread: buffer overflow");
Eric Laurent44d98482010-09-30 16:12:31 -07006073 lastWarning = now;
6074 }
6075 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07006076 // Release the processor for a while before asking for a new buffer.
6077 // This will give the application more chance to read from the buffer and
6078 // clear the overflow.
Eric Laurent7c7f10b2011-06-17 21:29:58 -07006079 usleep(kRecordThreadSleepUs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07006080 }
6081 }
Eric Laurentec437d82011-07-26 20:54:46 -07006082 // enable changes in effect chain
6083 unlockEffectChains(effectChains);
Eric Laurent7c7f10b2011-06-17 21:29:58 -07006084 effectChains.clear();
Mathias Agopian65ab4712010-07-14 17:59:35 -07006085 }
6086
6087 if (!mStandby) {
Dima Zavin799a70e2011-04-18 16:57:27 -07006088 mInput->stream->common.standby(&mInput->stream->common);
Mathias Agopian65ab4712010-07-14 17:59:35 -07006089 }
6090 mActiveTrack.clear();
6091
6092 mStartStopCond.broadcast();
6093
Eric Laurentfeb0db62011-07-22 09:04:31 -07006094 releaseWakeLock();
6095
Steve Block3856b092011-10-20 11:56:00 +01006096 ALOGV("RecordThread %p exiting", this);
Mathias Agopian65ab4712010-07-14 17:59:35 -07006097 return false;
6098}
6099
Eric Laurent7c7f10b2011-06-17 21:29:58 -07006100
6101sp<AudioFlinger::RecordThread::RecordTrack> AudioFlinger::RecordThread::createRecordTrack_l(
6102 const sp<AudioFlinger::Client>& client,
6103 uint32_t sampleRate,
Glenn Kasten58f30212012-01-12 12:27:51 -08006104 audio_format_t format,
Eric Laurent7c7f10b2011-06-17 21:29:58 -07006105 int channelMask,
6106 int frameCount,
Eric Laurent7c7f10b2011-06-17 21:29:58 -07006107 int sessionId,
6108 status_t *status)
6109{
6110 sp<RecordTrack> track;
6111 status_t lStatus;
6112
6113 lStatus = initCheck();
6114 if (lStatus != NO_ERROR) {
Steve Block29357bc2012-01-06 19:20:56 +00006115 ALOGE("Audio driver not initialized.");
Eric Laurent7c7f10b2011-06-17 21:29:58 -07006116 goto Exit;
6117 }
6118
6119 { // scope for mLock
6120 Mutex::Autolock _l(mLock);
6121
6122 track = new RecordTrack(this, client, sampleRate,
Glenn Kasten5cf034d2012-02-21 10:35:56 -08006123 format, channelMask, frameCount, sessionId);
Eric Laurent7c7f10b2011-06-17 21:29:58 -07006124
Glenn Kasten7378ca52012-01-20 13:44:40 -08006125 if (track->getCblk() == 0) {
Eric Laurent7c7f10b2011-06-17 21:29:58 -07006126 lStatus = NO_MEMORY;
6127 goto Exit;
6128 }
6129
6130 mTrack = track.get();
Eric Laurent59bd0da2011-08-01 09:52:20 -07006131 // disable AEC and NS if the device is a BT SCO headset supporting those pre processings
6132 bool suspend = audio_is_bluetooth_sco_device(
Eric Laurentbee53372011-08-29 12:42:48 -07006133 (audio_devices_t)(mDevice & AUDIO_DEVICE_IN_ALL)) && mAudioFlinger->btNrecIsOff();
Eric Laurent59bd0da2011-08-01 09:52:20 -07006134 setEffectSuspended_l(FX_IID_AEC, suspend, sessionId);
6135 setEffectSuspended_l(FX_IID_NS, suspend, sessionId);
Eric Laurent7c7f10b2011-06-17 21:29:58 -07006136 }
6137 lStatus = NO_ERROR;
6138
6139Exit:
6140 if (status) {
6141 *status = lStatus;
6142 }
6143 return track;
6144}
6145
Eric Laurenta011e352012-03-29 15:51:43 -07006146status_t AudioFlinger::RecordThread::start(RecordThread::RecordTrack* recordTrack,
Glenn Kasten3acbd052012-02-28 10:39:56 -08006147 AudioSystem::sync_event_t event,
Eric Laurenta011e352012-03-29 15:51:43 -07006148 int triggerSession)
Mathias Agopian65ab4712010-07-14 17:59:35 -07006149{
Glenn Kasten58912562012-04-03 10:45:00 -07006150 ALOGV("RecordThread::start event %d, triggerSession %d", event, triggerSession);
Glenn Kastene53b9ea2012-03-12 16:29:55 -07006151 sp<ThreadBase> strongMe = this;
Mathias Agopian65ab4712010-07-14 17:59:35 -07006152 status_t status = NO_ERROR;
Eric Laurenta011e352012-03-29 15:51:43 -07006153
6154 if (event == AudioSystem::SYNC_EVENT_NONE) {
Eric Laurent29864602012-05-08 18:57:51 -07006155 clearSyncStartEvent();
Eric Laurenta011e352012-03-29 15:51:43 -07006156 } else if (event != AudioSystem::SYNC_EVENT_SAME) {
6157 mSyncStartEvent = mAudioFlinger->createSyncEvent(event,
6158 triggerSession,
6159 recordTrack->sessionId(),
6160 syncStartEventCallback,
6161 this);
Eric Laurent29864602012-05-08 18:57:51 -07006162 // Sync event can be cancelled by the trigger session if the track is not in a
6163 // compatible state in which case we start record immediately
6164 if (mSyncStartEvent->isCancelled()) {
6165 clearSyncStartEvent();
6166 } else {
6167 // do not wait for the event for more than AudioSystem::kSyncRecordStartTimeOutMs
6168 mFramestoDrop = - ((AudioSystem::kSyncRecordStartTimeOutMs * mReqSampleRate) / 1000);
6169 }
Eric Laurenta011e352012-03-29 15:51:43 -07006170 }
6171
Mathias Agopian65ab4712010-07-14 17:59:35 -07006172 {
Glenn Kastena7d8d6f2012-01-05 15:41:56 -08006173 AutoMutex lock(mLock);
Mathias Agopian65ab4712010-07-14 17:59:35 -07006174 if (mActiveTrack != 0) {
6175 if (recordTrack != mActiveTrack.get()) {
6176 status = -EBUSY;
6177 } else if (mActiveTrack->mState == TrackBase::PAUSING) {
6178 mActiveTrack->mState = TrackBase::ACTIVE;
6179 }
6180 return status;
6181 }
6182
6183 recordTrack->mState = TrackBase::IDLE;
6184 mActiveTrack = recordTrack;
6185 mLock.unlock();
6186 status_t status = AudioSystem::startInput(mId);
6187 mLock.lock();
6188 if (status != NO_ERROR) {
6189 mActiveTrack.clear();
Eric Laurenta011e352012-03-29 15:51:43 -07006190 clearSyncStartEvent();
Mathias Agopian65ab4712010-07-14 17:59:35 -07006191 return status;
6192 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07006193 mRsmpInIndex = mFrameCount;
6194 mBytesRead = 0;
Eric Laurent243f5f92011-02-28 16:52:51 -08006195 if (mResampler != NULL) {
6196 mResampler->reset();
6197 }
6198 mActiveTrack->mState = TrackBase::RESUMING;
Mathias Agopian65ab4712010-07-14 17:59:35 -07006199 // signal thread to start
Steve Block3856b092011-10-20 11:56:00 +01006200 ALOGV("Signal record thread");
Mathias Agopian65ab4712010-07-14 17:59:35 -07006201 mWaitWorkCV.signal();
6202 // do not wait for mStartStopCond if exiting
Glenn Kastenb28686f2012-01-06 08:39:38 -08006203 if (exitPending()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07006204 mActiveTrack.clear();
6205 status = INVALID_OPERATION;
6206 goto startError;
6207 }
6208 mStartStopCond.wait(mLock);
6209 if (mActiveTrack == 0) {
Steve Block3856b092011-10-20 11:56:00 +01006210 ALOGV("Record failed to start");
Mathias Agopian65ab4712010-07-14 17:59:35 -07006211 status = BAD_VALUE;
6212 goto startError;
6213 }
Steve Block3856b092011-10-20 11:56:00 +01006214 ALOGV("Record started OK");
Mathias Agopian65ab4712010-07-14 17:59:35 -07006215 return status;
6216 }
6217startError:
6218 AudioSystem::stopInput(mId);
Eric Laurenta011e352012-03-29 15:51:43 -07006219 clearSyncStartEvent();
Mathias Agopian65ab4712010-07-14 17:59:35 -07006220 return status;
6221}
6222
Eric Laurenta011e352012-03-29 15:51:43 -07006223void AudioFlinger::RecordThread::clearSyncStartEvent()
6224{
6225 if (mSyncStartEvent != 0) {
6226 mSyncStartEvent->cancel();
6227 }
6228 mSyncStartEvent.clear();
Eric Laurent29864602012-05-08 18:57:51 -07006229 mFramestoDrop = 0;
Eric Laurenta011e352012-03-29 15:51:43 -07006230}
6231
6232void AudioFlinger::RecordThread::syncStartEventCallback(const wp<SyncEvent>& event)
6233{
6234 sp<SyncEvent> strongEvent = event.promote();
6235
6236 if (strongEvent != 0) {
6237 RecordThread *me = (RecordThread *)strongEvent->cookie();
6238 me->handleSyncStartEvent(strongEvent);
6239 }
6240}
6241
6242void AudioFlinger::RecordThread::handleSyncStartEvent(const sp<SyncEvent>& event)
6243{
Eric Laurent29864602012-05-08 18:57:51 -07006244 if (event == mSyncStartEvent) {
Eric Laurenta011e352012-03-29 15:51:43 -07006245 // TODO: use actual buffer filling status instead of 2 buffers when info is available
6246 // from audio HAL
6247 mFramestoDrop = mFrameCount * 2;
Eric Laurenta011e352012-03-29 15:51:43 -07006248 }
6249}
6250
Mathias Agopian65ab4712010-07-14 17:59:35 -07006251void AudioFlinger::RecordThread::stop(RecordThread::RecordTrack* recordTrack) {
Steve Block3856b092011-10-20 11:56:00 +01006252 ALOGV("RecordThread::stop");
Glenn Kastene53b9ea2012-03-12 16:29:55 -07006253 sp<ThreadBase> strongMe = this;
Mathias Agopian65ab4712010-07-14 17:59:35 -07006254 {
Glenn Kastena7d8d6f2012-01-05 15:41:56 -08006255 AutoMutex lock(mLock);
Mathias Agopian65ab4712010-07-14 17:59:35 -07006256 if (mActiveTrack != 0 && recordTrack == mActiveTrack.get()) {
6257 mActiveTrack->mState = TrackBase::PAUSING;
6258 // do not wait for mStartStopCond if exiting
Glenn Kastenb28686f2012-01-06 08:39:38 -08006259 if (exitPending()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07006260 return;
6261 }
6262 mStartStopCond.wait(mLock);
6263 // if we have been restarted, recordTrack == mActiveTrack.get() here
6264 if (mActiveTrack == 0 || recordTrack != mActiveTrack.get()) {
6265 mLock.unlock();
6266 AudioSystem::stopInput(mId);
6267 mLock.lock();
Steve Block3856b092011-10-20 11:56:00 +01006268 ALOGV("Record stopped OK");
Mathias Agopian65ab4712010-07-14 17:59:35 -07006269 }
6270 }
6271 }
6272}
6273
Eric Laurenta011e352012-03-29 15:51:43 -07006274bool AudioFlinger::RecordThread::isValidSyncEvent(const sp<SyncEvent>& event)
6275{
6276 return false;
6277}
6278
6279status_t AudioFlinger::RecordThread::setSyncEvent(const sp<SyncEvent>& event)
6280{
6281 if (!isValidSyncEvent(event)) {
6282 return BAD_VALUE;
6283 }
6284
6285 Mutex::Autolock _l(mLock);
6286
6287 if (mTrack != NULL && event->triggerSession() == mTrack->sessionId()) {
6288 mTrack->setSyncEvent(event);
6289 return NO_ERROR;
6290 }
6291 return NAME_NOT_FOUND;
6292}
6293
Mathias Agopian65ab4712010-07-14 17:59:35 -07006294status_t AudioFlinger::RecordThread::dump(int fd, const Vector<String16>& args)
6295{
6296 const size_t SIZE = 256;
6297 char buffer[SIZE];
6298 String8 result;
Mathias Agopian65ab4712010-07-14 17:59:35 -07006299
6300 snprintf(buffer, SIZE, "\nInput thread %p internals\n", this);
6301 result.append(buffer);
6302
6303 if (mActiveTrack != 0) {
6304 result.append("Active Track:\n");
Jean-Michel Trivi0d255b22011-05-24 15:53:33 -07006305 result.append(" Clien Fmt Chn mask Session Buf S SRate Serv User\n");
Mathias Agopian65ab4712010-07-14 17:59:35 -07006306 mActiveTrack->dump(buffer, SIZE);
6307 result.append(buffer);
6308
6309 snprintf(buffer, SIZE, "In index: %d\n", mRsmpInIndex);
6310 result.append(buffer);
6311 snprintf(buffer, SIZE, "In size: %d\n", mInputBytes);
6312 result.append(buffer);
Glenn Kastene0feee32011-12-13 11:53:26 -08006313 snprintf(buffer, SIZE, "Resampling: %d\n", (mResampler != NULL));
Mathias Agopian65ab4712010-07-14 17:59:35 -07006314 result.append(buffer);
6315 snprintf(buffer, SIZE, "Out channel count: %d\n", mReqChannelCount);
6316 result.append(buffer);
6317 snprintf(buffer, SIZE, "Out sample rate: %d\n", mReqSampleRate);
6318 result.append(buffer);
6319
6320
6321 } else {
6322 result.append("No record client\n");
6323 }
6324 write(fd, result.string(), result.size());
6325
6326 dumpBase(fd, args);
Eric Laurent1d2bff02011-07-24 17:49:51 -07006327 dumpEffectChains(fd, args);
Mathias Agopian65ab4712010-07-14 17:59:35 -07006328
6329 return NO_ERROR;
6330}
6331
Glenn Kasten01c4ebf2012-02-22 10:47:35 -08006332// AudioBufferProvider interface
John Grossman4ff14ba2012-02-08 16:37:41 -08006333status_t AudioFlinger::RecordThread::getNextBuffer(AudioBufferProvider::Buffer* buffer, int64_t pts)
Mathias Agopian65ab4712010-07-14 17:59:35 -07006334{
6335 size_t framesReq = buffer->frameCount;
6336 size_t framesReady = mFrameCount - mRsmpInIndex;
6337 int channelCount;
6338
6339 if (framesReady == 0) {
Dima Zavin799a70e2011-04-18 16:57:27 -07006340 mBytesRead = mInput->stream->read(mInput->stream, mRsmpInBuffer, mInputBytes);
Mathias Agopian65ab4712010-07-14 17:59:35 -07006341 if (mBytesRead < 0) {
Steve Block29357bc2012-01-06 19:20:56 +00006342 ALOGE("RecordThread::getNextBuffer() Error reading audio input");
Mathias Agopian65ab4712010-07-14 17:59:35 -07006343 if (mActiveTrack->mState == TrackBase::ACTIVE) {
6344 // Force input into standby so that it tries to
6345 // recover at next read attempt
Dima Zavin799a70e2011-04-18 16:57:27 -07006346 mInput->stream->common.standby(&mInput->stream->common);
Eric Laurent7c7f10b2011-06-17 21:29:58 -07006347 usleep(kRecordThreadSleepUs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07006348 }
Glenn Kastene0feee32011-12-13 11:53:26 -08006349 buffer->raw = NULL;
Mathias Agopian65ab4712010-07-14 17:59:35 -07006350 buffer->frameCount = 0;
6351 return NOT_ENOUGH_DATA;
6352 }
6353 mRsmpInIndex = 0;
6354 framesReady = mFrameCount;
6355 }
6356
6357 if (framesReq > framesReady) {
6358 framesReq = framesReady;
6359 }
6360
6361 if (mChannelCount == 1 && mReqChannelCount == 2) {
6362 channelCount = 1;
6363 } else {
6364 channelCount = 2;
6365 }
6366 buffer->raw = mRsmpInBuffer + mRsmpInIndex * channelCount;
6367 buffer->frameCount = framesReq;
6368 return NO_ERROR;
6369}
6370
Glenn Kasten01c4ebf2012-02-22 10:47:35 -08006371// AudioBufferProvider interface
Mathias Agopian65ab4712010-07-14 17:59:35 -07006372void AudioFlinger::RecordThread::releaseBuffer(AudioBufferProvider::Buffer* buffer)
6373{
6374 mRsmpInIndex += buffer->frameCount;
6375 buffer->frameCount = 0;
6376}
6377
6378bool AudioFlinger::RecordThread::checkForNewParameters_l()
6379{
6380 bool reconfig = false;
6381
6382 while (!mNewParameters.isEmpty()) {
6383 status_t status = NO_ERROR;
6384 String8 keyValuePair = mNewParameters[0];
6385 AudioParameter param = AudioParameter(keyValuePair);
6386 int value;
Glenn Kasten58f30212012-01-12 12:27:51 -08006387 audio_format_t reqFormat = mFormat;
Mathias Agopian65ab4712010-07-14 17:59:35 -07006388 int reqSamplingRate = mReqSampleRate;
6389 int reqChannelCount = mReqChannelCount;
6390
6391 if (param.getInt(String8(AudioParameter::keySamplingRate), value) == NO_ERROR) {
6392 reqSamplingRate = value;
6393 reconfig = true;
6394 }
6395 if (param.getInt(String8(AudioParameter::keyFormat), value) == NO_ERROR) {
Glenn Kasten58f30212012-01-12 12:27:51 -08006396 reqFormat = (audio_format_t) value;
Mathias Agopian65ab4712010-07-14 17:59:35 -07006397 reconfig = true;
6398 }
6399 if (param.getInt(String8(AudioParameter::keyChannels), value) == NO_ERROR) {
Dima Zavinfce7a472011-04-19 22:30:36 -07006400 reqChannelCount = popcount(value);
Mathias Agopian65ab4712010-07-14 17:59:35 -07006401 reconfig = true;
6402 }
6403 if (param.getInt(String8(AudioParameter::keyFrameCount), value) == NO_ERROR) {
6404 // do not accept frame count changes if tracks are open as the track buffer
Glenn Kasten99e53b82012-01-19 08:59:58 -08006405 // size depends on frame count and correct behavior would not be guaranteed
Mathias Agopian65ab4712010-07-14 17:59:35 -07006406 // if frame count is changed after track creation
6407 if (mActiveTrack != 0) {
6408 status = INVALID_OPERATION;
6409 } else {
6410 reconfig = true;
6411 }
6412 }
Eric Laurent7c7f10b2011-06-17 21:29:58 -07006413 if (param.getInt(String8(AudioParameter::keyRouting), value) == NO_ERROR) {
6414 // forward device change to effects that have requested to be
6415 // aware of attached audio device.
6416 for (size_t i = 0; i < mEffectChains.size(); i++) {
6417 mEffectChains[i]->setDevice_l(value);
6418 }
6419 // store input device and output device but do not forward output device to audio HAL.
6420 // Note that status is ignored by the caller for output device
6421 // (see AudioFlinger::setParameters()
6422 if (value & AUDIO_DEVICE_OUT_ALL) {
6423 mDevice &= (uint32_t)~(value & AUDIO_DEVICE_OUT_ALL);
6424 status = BAD_VALUE;
6425 } else {
6426 mDevice &= (uint32_t)~(value & AUDIO_DEVICE_IN_ALL);
Eric Laurent59bd0da2011-08-01 09:52:20 -07006427 // disable AEC and NS if the device is a BT SCO headset supporting those pre processings
6428 if (mTrack != NULL) {
6429 bool suspend = audio_is_bluetooth_sco_device(
Eric Laurentbee53372011-08-29 12:42:48 -07006430 (audio_devices_t)value) && mAudioFlinger->btNrecIsOff();
Eric Laurent59bd0da2011-08-01 09:52:20 -07006431 setEffectSuspended_l(FX_IID_AEC, suspend, mTrack->sessionId());
6432 setEffectSuspended_l(FX_IID_NS, suspend, mTrack->sessionId());
6433 }
Eric Laurent7c7f10b2011-06-17 21:29:58 -07006434 }
6435 mDevice |= (uint32_t)value;
6436 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07006437 if (status == NO_ERROR) {
Dima Zavin799a70e2011-04-18 16:57:27 -07006438 status = mInput->stream->common.set_parameters(&mInput->stream->common, keyValuePair.string());
Mathias Agopian65ab4712010-07-14 17:59:35 -07006439 if (status == INVALID_OPERATION) {
Glenn Kastene53b9ea2012-03-12 16:29:55 -07006440 mInput->stream->common.standby(&mInput->stream->common);
6441 status = mInput->stream->common.set_parameters(&mInput->stream->common,
6442 keyValuePair.string());
Mathias Agopian65ab4712010-07-14 17:59:35 -07006443 }
6444 if (reconfig) {
6445 if (status == BAD_VALUE &&
Dima Zavin799a70e2011-04-18 16:57:27 -07006446 reqFormat == mInput->stream->common.get_format(&mInput->stream->common) &&
Dima Zavinfce7a472011-04-19 22:30:36 -07006447 reqFormat == AUDIO_FORMAT_PCM_16_BIT &&
Dima Zavin799a70e2011-04-18 16:57:27 -07006448 ((int)mInput->stream->common.get_sample_rate(&mInput->stream->common) <= (2 * reqSamplingRate)) &&
Glenn Kasten53d76db2012-03-08 12:32:47 -08006449 popcount(mInput->stream->common.get_channels(&mInput->stream->common)) <= FCC_2 &&
6450 (reqChannelCount <= FCC_2)) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07006451 status = NO_ERROR;
6452 }
6453 if (status == NO_ERROR) {
6454 readInputParameters();
6455 sendConfigEvent_l(AudioSystem::INPUT_CONFIG_CHANGED);
6456 }
6457 }
6458 }
6459
6460 mNewParameters.removeAt(0);
6461
6462 mParamStatus = status;
6463 mParamCond.signal();
Eric Laurent60cd0a02011-09-13 11:40:21 -07006464 // wait for condition with time out in case the thread calling ThreadBase::setParameters()
6465 // already timed out waiting for the status and will never signal the condition.
Glenn Kasten7dede872011-12-13 11:04:14 -08006466 mWaitWorkCV.waitRelative(mLock, kSetParametersTimeoutNs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07006467 }
6468 return reconfig;
6469}
6470
6471String8 AudioFlinger::RecordThread::getParameters(const String8& keys)
6472{
Dima Zavinfce7a472011-04-19 22:30:36 -07006473 char *s;
Eric Laurentb8ba0a92011-08-07 16:32:26 -07006474 String8 out_s8 = String8();
6475
6476 Mutex::Autolock _l(mLock);
6477 if (initCheck() != NO_ERROR) {
6478 return out_s8;
6479 }
Dima Zavinfce7a472011-04-19 22:30:36 -07006480
Dima Zavin799a70e2011-04-18 16:57:27 -07006481 s = mInput->stream->common.get_parameters(&mInput->stream->common, keys.string());
Dima Zavinfce7a472011-04-19 22:30:36 -07006482 out_s8 = String8(s);
6483 free(s);
6484 return out_s8;
Mathias Agopian65ab4712010-07-14 17:59:35 -07006485}
6486
6487void AudioFlinger::RecordThread::audioConfigChanged_l(int event, int param) {
6488 AudioSystem::OutputDescriptor desc;
Glenn Kastena0d68332012-01-27 16:47:15 -08006489 void *param2 = NULL;
Mathias Agopian65ab4712010-07-14 17:59:35 -07006490
6491 switch (event) {
6492 case AudioSystem::INPUT_OPENED:
6493 case AudioSystem::INPUT_CONFIG_CHANGED:
Jean-Michel Trivi0d255b22011-05-24 15:53:33 -07006494 desc.channels = mChannelMask;
Mathias Agopian65ab4712010-07-14 17:59:35 -07006495 desc.samplingRate = mSampleRate;
6496 desc.format = mFormat;
6497 desc.frameCount = mFrameCount;
6498 desc.latency = 0;
6499 param2 = &desc;
6500 break;
6501
6502 case AudioSystem::INPUT_CLOSED:
6503 default:
6504 break;
6505 }
6506 mAudioFlinger->audioConfigChanged_l(event, mId, param2);
6507}
6508
6509void AudioFlinger::RecordThread::readInputParameters()
6510{
Glenn Kastene9dd0172012-01-27 18:08:45 -08006511 delete mRsmpInBuffer;
6512 // mRsmpInBuffer is always assigned a new[] below
6513 delete mRsmpOutBuffer;
6514 mRsmpOutBuffer = NULL;
6515 delete mResampler;
Glenn Kastene0feee32011-12-13 11:53:26 -08006516 mResampler = NULL;
Mathias Agopian65ab4712010-07-14 17:59:35 -07006517
Dima Zavin799a70e2011-04-18 16:57:27 -07006518 mSampleRate = mInput->stream->common.get_sample_rate(&mInput->stream->common);
Jean-Michel Trivi0d255b22011-05-24 15:53:33 -07006519 mChannelMask = mInput->stream->common.get_channels(&mInput->stream->common);
6520 mChannelCount = (uint16_t)popcount(mChannelMask);
Dima Zavin799a70e2011-04-18 16:57:27 -07006521 mFormat = mInput->stream->common.get_format(&mInput->stream->common);
Glenn Kastenb9980652012-01-11 09:48:27 -08006522 mFrameSize = audio_stream_frame_size(&mInput->stream->common);
Dima Zavin799a70e2011-04-18 16:57:27 -07006523 mInputBytes = mInput->stream->common.get_buffer_size(&mInput->stream->common);
Mathias Agopian65ab4712010-07-14 17:59:35 -07006524 mFrameCount = mInputBytes / mFrameSize;
Glenn Kasten58912562012-04-03 10:45:00 -07006525 mNormalFrameCount = mFrameCount; // not used by record, but used by input effects
Mathias Agopian65ab4712010-07-14 17:59:35 -07006526 mRsmpInBuffer = new int16_t[mFrameCount * mChannelCount];
6527
Glenn Kasten53d76db2012-03-08 12:32:47 -08006528 if (mSampleRate != mReqSampleRate && mChannelCount <= FCC_2 && mReqChannelCount <= FCC_2)
Mathias Agopian65ab4712010-07-14 17:59:35 -07006529 {
6530 int channelCount;
Glenn Kastene53b9ea2012-03-12 16:29:55 -07006531 // optimization: if mono to mono, use the resampler in stereo to stereo mode to avoid
6532 // stereo to mono post process as the resampler always outputs stereo.
Mathias Agopian65ab4712010-07-14 17:59:35 -07006533 if (mChannelCount == 1 && mReqChannelCount == 2) {
6534 channelCount = 1;
6535 } else {
6536 channelCount = 2;
6537 }
6538 mResampler = AudioResampler::create(16, channelCount, mReqSampleRate);
6539 mResampler->setSampleRate(mSampleRate);
6540 mResampler->setVolume(AudioMixer::UNITY_GAIN, AudioMixer::UNITY_GAIN);
6541 mRsmpOutBuffer = new int32_t[mFrameCount * 2];
6542
6543 // optmization: if mono to mono, alter input frame count as if we were inputing stereo samples
6544 if (mChannelCount == 1 && mReqChannelCount == 1) {
6545 mFrameCount >>= 1;
6546 }
6547
6548 }
6549 mRsmpInIndex = mFrameCount;
6550}
6551
6552unsigned int AudioFlinger::RecordThread::getInputFramesLost()
6553{
Eric Laurentb8ba0a92011-08-07 16:32:26 -07006554 Mutex::Autolock _l(mLock);
6555 if (initCheck() != NO_ERROR) {
6556 return 0;
6557 }
6558
Dima Zavin799a70e2011-04-18 16:57:27 -07006559 return mInput->stream->get_input_frames_lost(mInput->stream);
Mathias Agopian65ab4712010-07-14 17:59:35 -07006560}
6561
Eric Laurent7c7f10b2011-06-17 21:29:58 -07006562uint32_t AudioFlinger::RecordThread::hasAudioSession(int sessionId)
6563{
6564 Mutex::Autolock _l(mLock);
6565 uint32_t result = 0;
6566 if (getEffectChain_l(sessionId) != 0) {
6567 result = EFFECT_SESSION;
6568 }
6569
6570 if (mTrack != NULL && sessionId == mTrack->sessionId()) {
6571 result |= TRACK_SESSION;
6572 }
6573
6574 return result;
6575}
6576
Eric Laurent59bd0da2011-08-01 09:52:20 -07006577AudioFlinger::RecordThread::RecordTrack* AudioFlinger::RecordThread::track()
6578{
6579 Mutex::Autolock _l(mLock);
6580 return mTrack;
6581}
6582
Glenn Kastenaed850d2012-01-26 09:46:34 -08006583AudioFlinger::AudioStreamIn* AudioFlinger::RecordThread::getInput() const
Eric Laurentb8ba0a92011-08-07 16:32:26 -07006584{
6585 Mutex::Autolock _l(mLock);
6586 return mInput;
6587}
6588
6589AudioFlinger::AudioStreamIn* AudioFlinger::RecordThread::clearInput()
6590{
6591 Mutex::Autolock _l(mLock);
6592 AudioStreamIn *input = mInput;
6593 mInput = NULL;
6594 return input;
6595}
6596
6597// this method must always be called either with ThreadBase mLock held or inside the thread loop
Glenn Kasten0bf65bd2012-02-28 18:32:53 -08006598audio_stream_t* AudioFlinger::RecordThread::stream() const
Eric Laurentb8ba0a92011-08-07 16:32:26 -07006599{
6600 if (mInput == NULL) {
6601 return NULL;
6602 }
6603 return &mInput->stream->common;
6604}
6605
6606
Mathias Agopian65ab4712010-07-14 17:59:35 -07006607// ----------------------------------------------------------------------------
6608
Eric Laurenta4c5a552012-03-29 10:12:40 -07006609audio_module_handle_t AudioFlinger::loadHwModule(const char *name)
6610{
6611 if (!settingsAllowed()) {
6612 return 0;
6613 }
6614 Mutex::Autolock _l(mLock);
6615 return loadHwModule_l(name);
6616}
6617
6618// loadHwModule_l() must be called with AudioFlinger::mLock held
6619audio_module_handle_t AudioFlinger::loadHwModule_l(const char *name)
6620{
6621 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
6622 if (strncmp(mAudioHwDevs.valueAt(i)->moduleName(), name, strlen(name)) == 0) {
6623 ALOGW("loadHwModule() module %s already loaded", name);
6624 return mAudioHwDevs.keyAt(i);
6625 }
6626 }
6627
Eric Laurenta4c5a552012-03-29 10:12:40 -07006628 audio_hw_device_t *dev;
6629
Eric Laurentf7ffb8b2012-04-14 09:06:57 -07006630 int rc = load_audio_interface(name, &dev);
Eric Laurenta4c5a552012-03-29 10:12:40 -07006631 if (rc) {
6632 ALOGI("loadHwModule() error %d loading module %s ", rc, name);
6633 return 0;
6634 }
6635
6636 mHardwareStatus = AUDIO_HW_INIT;
6637 rc = dev->init_check(dev);
6638 mHardwareStatus = AUDIO_HW_IDLE;
6639 if (rc) {
6640 ALOGI("loadHwModule() init check error %d for module %s ", rc, name);
6641 return 0;
6642 }
6643
6644 if ((mMasterVolumeSupportLvl != MVS_NONE) &&
6645 (NULL != dev->set_master_volume)) {
6646 AutoMutex lock(mHardwareLock);
6647 mHardwareStatus = AUDIO_HW_SET_MASTER_VOLUME;
6648 dev->set_master_volume(dev, mMasterVolume);
6649 mHardwareStatus = AUDIO_HW_IDLE;
6650 }
6651
6652 audio_module_handle_t handle = nextUniqueId();
6653 mAudioHwDevs.add(handle, new AudioHwDevice(name, dev));
6654
6655 ALOGI("loadHwModule() Loaded %s audio interface from %s (%s) handle %d",
Eric Laurentf7ffb8b2012-04-14 09:06:57 -07006656 name, dev->common.module->name, dev->common.module->id, handle);
Eric Laurenta4c5a552012-03-29 10:12:40 -07006657
6658 return handle;
6659
6660}
6661
6662audio_io_handle_t AudioFlinger::openOutput(audio_module_handle_t module,
6663 audio_devices_t *pDevices,
6664 uint32_t *pSamplingRate,
6665 audio_format_t *pFormat,
6666 audio_channel_mask_t *pChannelMask,
6667 uint32_t *pLatencyMs,
Eric Laurent0ca3cf92012-04-18 09:24:29 -07006668 audio_output_flags_t flags)
Mathias Agopian65ab4712010-07-14 17:59:35 -07006669{
6670 status_t status;
6671 PlaybackThread *thread = NULL;
Eric Laurentf7ffb8b2012-04-14 09:06:57 -07006672 struct audio_config config = {
6673 sample_rate: pSamplingRate ? *pSamplingRate : 0,
6674 channel_mask: pChannelMask ? *pChannelMask : 0,
6675 format: pFormat ? *pFormat : AUDIO_FORMAT_DEFAULT,
6676 };
6677 audio_stream_out_t *outStream = NULL;
Dima Zavin799a70e2011-04-18 16:57:27 -07006678 audio_hw_device_t *outHwDev;
Mathias Agopian65ab4712010-07-14 17:59:35 -07006679
Eric Laurenta4c5a552012-03-29 10:12:40 -07006680 ALOGV("openOutput(), module %d Device %x, SamplingRate %d, Format %d, Channels %x, flags %x",
6681 module,
Eric Laurent3f9c84c2012-04-03 15:36:53 -07006682 (pDevices != NULL) ? (int)*pDevices : 0,
Eric Laurentf7ffb8b2012-04-14 09:06:57 -07006683 config.sample_rate,
6684 config.format,
6685 config.channel_mask,
Eric Laurenta4c5a552012-03-29 10:12:40 -07006686 flags);
Mathias Agopian65ab4712010-07-14 17:59:35 -07006687
6688 if (pDevices == NULL || *pDevices == 0) {
6689 return 0;
6690 }
Dima Zavin799a70e2011-04-18 16:57:27 -07006691
Mathias Agopian65ab4712010-07-14 17:59:35 -07006692 Mutex::Autolock _l(mLock);
6693
Eric Laurenta4c5a552012-03-29 10:12:40 -07006694 outHwDev = findSuitableHwDev_l(module, *pDevices);
Dima Zavin799a70e2011-04-18 16:57:27 -07006695 if (outHwDev == NULL)
6696 return 0;
6697
Eric Laurentf7ffb8b2012-04-14 09:06:57 -07006698 audio_io_handle_t id = nextUniqueId();
6699
Glenn Kasten8abf44d2012-02-02 14:16:03 -08006700 mHardwareStatus = AUDIO_HW_OUTPUT_OPEN;
Eric Laurentf7ffb8b2012-04-14 09:06:57 -07006701
6702 status = outHwDev->open_output_stream(outHwDev,
6703 id,
6704 *pDevices,
6705 (audio_output_flags_t)flags,
6706 &config,
6707 &outStream);
6708
Glenn Kasten8abf44d2012-02-02 14:16:03 -08006709 mHardwareStatus = AUDIO_HW_IDLE;
Steve Block3856b092011-10-20 11:56:00 +01006710 ALOGV("openOutput() openOutputStream returned output %p, SamplingRate %d, Format %d, Channels %x, status %d",
Dima Zavin799a70e2011-04-18 16:57:27 -07006711 outStream,
Eric Laurentf7ffb8b2012-04-14 09:06:57 -07006712 config.sample_rate,
6713 config.format,
6714 config.channel_mask,
Mathias Agopian65ab4712010-07-14 17:59:35 -07006715 status);
6716
Eric Laurentf7ffb8b2012-04-14 09:06:57 -07006717 if (status == NO_ERROR && outStream != NULL) {
Dima Zavin799a70e2011-04-18 16:57:27 -07006718 AudioStreamOut *output = new AudioStreamOut(outHwDev, outStream);
Dima Zavin799a70e2011-04-18 16:57:27 -07006719
Eric Laurent0ca3cf92012-04-18 09:24:29 -07006720 if ((flags & AUDIO_OUTPUT_FLAG_DIRECT) ||
Eric Laurentf7ffb8b2012-04-14 09:06:57 -07006721 (config.format != AUDIO_FORMAT_PCM_16_BIT) ||
6722 (config.channel_mask != AUDIO_CHANNEL_OUT_STEREO)) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07006723 thread = new DirectOutputThread(this, output, id, *pDevices);
Steve Block3856b092011-10-20 11:56:00 +01006724 ALOGV("openOutput() created direct output: ID %d thread %p", id, thread);
Mathias Agopian65ab4712010-07-14 17:59:35 -07006725 } else {
6726 thread = new MixerThread(this, output, id, *pDevices);
Steve Block3856b092011-10-20 11:56:00 +01006727 ALOGV("openOutput() created mixer output: ID %d thread %p", id, thread);
Mathias Agopian65ab4712010-07-14 17:59:35 -07006728 }
6729 mPlaybackThreads.add(id, thread);
6730
Eric Laurentf7ffb8b2012-04-14 09:06:57 -07006731 if (pSamplingRate != NULL) *pSamplingRate = config.sample_rate;
6732 if (pFormat != NULL) *pFormat = config.format;
6733 if (pChannelMask != NULL) *pChannelMask = config.channel_mask;
Glenn Kastena0d68332012-01-27 16:47:15 -08006734 if (pLatencyMs != NULL) *pLatencyMs = thread->latency();
Mathias Agopian65ab4712010-07-14 17:59:35 -07006735
6736 // notify client processes of the new output creation
6737 thread->audioConfigChanged_l(AudioSystem::OUTPUT_OPENED);
Eric Laurenta4c5a552012-03-29 10:12:40 -07006738
6739 // the first primary output opened designates the primary hw device
Eric Laurent0ca3cf92012-04-18 09:24:29 -07006740 if ((mPrimaryHardwareDev == NULL) && (flags & AUDIO_OUTPUT_FLAG_PRIMARY)) {
Eric Laurenta4c5a552012-03-29 10:12:40 -07006741 ALOGI("Using module %d has the primary audio interface", module);
6742 mPrimaryHardwareDev = outHwDev;
6743
6744 AutoMutex lock(mHardwareLock);
6745 mHardwareStatus = AUDIO_HW_SET_MODE;
6746 outHwDev->set_mode(outHwDev, mMode);
6747
6748 // Determine the level of master volume support the primary audio HAL has,
6749 // and set the initial master volume at the same time.
6750 float initialVolume = 1.0;
6751 mMasterVolumeSupportLvl = MVS_NONE;
6752
6753 mHardwareStatus = AUDIO_HW_GET_MASTER_VOLUME;
6754 if ((NULL != outHwDev->get_master_volume) &&
6755 (NO_ERROR == outHwDev->get_master_volume(outHwDev, &initialVolume))) {
6756 mMasterVolumeSupportLvl = MVS_FULL;
6757 } else {
6758 mMasterVolumeSupportLvl = MVS_SETONLY;
6759 initialVolume = 1.0;
6760 }
6761
6762 mHardwareStatus = AUDIO_HW_SET_MASTER_VOLUME;
6763 if ((NULL == outHwDev->set_master_volume) ||
6764 (NO_ERROR != outHwDev->set_master_volume(outHwDev, initialVolume))) {
6765 mMasterVolumeSupportLvl = MVS_NONE;
6766 }
6767 // now that we have a primary device, initialize master volume on other devices
6768 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
6769 audio_hw_device_t *dev = mAudioHwDevs.valueAt(i)->hwDevice();
6770
6771 if ((dev != mPrimaryHardwareDev) &&
6772 (NULL != dev->set_master_volume)) {
6773 dev->set_master_volume(dev, initialVolume);
6774 }
6775 }
6776 mHardwareStatus = AUDIO_HW_IDLE;
6777 mMasterVolumeSW = (MVS_NONE == mMasterVolumeSupportLvl)
6778 ? initialVolume
6779 : 1.0;
6780 mMasterVolume = initialVolume;
6781 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07006782 return id;
6783 }
6784
6785 return 0;
6786}
6787
Glenn Kasten72ef00d2012-01-17 11:09:42 -08006788audio_io_handle_t AudioFlinger::openDuplicateOutput(audio_io_handle_t output1,
6789 audio_io_handle_t output2)
Mathias Agopian65ab4712010-07-14 17:59:35 -07006790{
6791 Mutex::Autolock _l(mLock);
6792 MixerThread *thread1 = checkMixerThread_l(output1);
6793 MixerThread *thread2 = checkMixerThread_l(output2);
6794
6795 if (thread1 == NULL || thread2 == NULL) {
Steve Block5ff1dd52012-01-05 23:22:43 +00006796 ALOGW("openDuplicateOutput() wrong output mixer type for output %d or %d", output1, output2);
Mathias Agopian65ab4712010-07-14 17:59:35 -07006797 return 0;
6798 }
6799
Glenn Kasten72ef00d2012-01-17 11:09:42 -08006800 audio_io_handle_t id = nextUniqueId();
Mathias Agopian65ab4712010-07-14 17:59:35 -07006801 DuplicatingThread *thread = new DuplicatingThread(this, thread1, id);
6802 thread->addOutputTrack(thread2);
6803 mPlaybackThreads.add(id, thread);
6804 // notify client processes of the new output creation
6805 thread->audioConfigChanged_l(AudioSystem::OUTPUT_OPENED);
6806 return id;
6807}
6808
Glenn Kasten72ef00d2012-01-17 11:09:42 -08006809status_t AudioFlinger::closeOutput(audio_io_handle_t output)
Mathias Agopian65ab4712010-07-14 17:59:35 -07006810{
6811 // keep strong reference on the playback thread so that
6812 // it is not destroyed while exit() is executed
Glenn Kastene53b9ea2012-03-12 16:29:55 -07006813 sp<PlaybackThread> thread;
Mathias Agopian65ab4712010-07-14 17:59:35 -07006814 {
6815 Mutex::Autolock _l(mLock);
6816 thread = checkPlaybackThread_l(output);
6817 if (thread == NULL) {
6818 return BAD_VALUE;
6819 }
6820
Steve Block3856b092011-10-20 11:56:00 +01006821 ALOGV("closeOutput() %d", output);
Mathias Agopian65ab4712010-07-14 17:59:35 -07006822
Eric Laurent7c7f10b2011-06-17 21:29:58 -07006823 if (thread->type() == ThreadBase::MIXER) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07006824 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
Eric Laurent7c7f10b2011-06-17 21:29:58 -07006825 if (mPlaybackThreads.valueAt(i)->type() == ThreadBase::DUPLICATING) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07006826 DuplicatingThread *dupThread = (DuplicatingThread *)mPlaybackThreads.valueAt(i).get();
6827 dupThread->removeOutputTrack((MixerThread *)thread.get());
6828 }
6829 }
6830 }
Glenn Kastena1117922012-01-26 10:53:32 -08006831 audioConfigChanged_l(AudioSystem::OUTPUT_CLOSED, output, NULL);
Mathias Agopian65ab4712010-07-14 17:59:35 -07006832 mPlaybackThreads.removeItem(output);
6833 }
6834 thread->exit();
Glenn Kastenb28686f2012-01-06 08:39:38 -08006835 // The thread entity (active unit of execution) is no longer running here,
6836 // but the ThreadBase container still exists.
Mathias Agopian65ab4712010-07-14 17:59:35 -07006837
Eric Laurent7c7f10b2011-06-17 21:29:58 -07006838 if (thread->type() != ThreadBase::DUPLICATING) {
Eric Laurentb8ba0a92011-08-07 16:32:26 -07006839 AudioStreamOut *out = thread->clearOutput();
Glenn Kasten5798d4e2012-03-08 12:18:35 -08006840 ALOG_ASSERT(out != NULL, "out shouldn't be NULL");
Eric Laurentb8ba0a92011-08-07 16:32:26 -07006841 // from now on thread->mOutput is NULL
Dima Zavin799a70e2011-04-18 16:57:27 -07006842 out->hwDev->close_output_stream(out->hwDev, out->stream);
6843 delete out;
Mathias Agopian65ab4712010-07-14 17:59:35 -07006844 }
6845 return NO_ERROR;
6846}
6847
Glenn Kasten72ef00d2012-01-17 11:09:42 -08006848status_t AudioFlinger::suspendOutput(audio_io_handle_t output)
Mathias Agopian65ab4712010-07-14 17:59:35 -07006849{
6850 Mutex::Autolock _l(mLock);
6851 PlaybackThread *thread = checkPlaybackThread_l(output);
6852
6853 if (thread == NULL) {
6854 return BAD_VALUE;
6855 }
6856
Steve Block3856b092011-10-20 11:56:00 +01006857 ALOGV("suspendOutput() %d", output);
Mathias Agopian65ab4712010-07-14 17:59:35 -07006858 thread->suspend();
6859
6860 return NO_ERROR;
6861}
6862
Glenn Kasten72ef00d2012-01-17 11:09:42 -08006863status_t AudioFlinger::restoreOutput(audio_io_handle_t output)
Mathias Agopian65ab4712010-07-14 17:59:35 -07006864{
6865 Mutex::Autolock _l(mLock);
6866 PlaybackThread *thread = checkPlaybackThread_l(output);
6867
6868 if (thread == NULL) {
6869 return BAD_VALUE;
6870 }
6871
Steve Block3856b092011-10-20 11:56:00 +01006872 ALOGV("restoreOutput() %d", output);
Mathias Agopian65ab4712010-07-14 17:59:35 -07006873
6874 thread->restore();
6875
6876 return NO_ERROR;
6877}
6878
Eric Laurenta4c5a552012-03-29 10:12:40 -07006879audio_io_handle_t AudioFlinger::openInput(audio_module_handle_t module,
6880 audio_devices_t *pDevices,
6881 uint32_t *pSamplingRate,
6882 audio_format_t *pFormat,
6883 uint32_t *pChannelMask)
Mathias Agopian65ab4712010-07-14 17:59:35 -07006884{
6885 status_t status;
6886 RecordThread *thread = NULL;
Eric Laurentf7ffb8b2012-04-14 09:06:57 -07006887 struct audio_config config = {
6888 sample_rate: pSamplingRate ? *pSamplingRate : 0,
6889 channel_mask: pChannelMask ? *pChannelMask : 0,
6890 format: pFormat ? *pFormat : AUDIO_FORMAT_DEFAULT,
6891 };
6892 uint32_t reqSamplingRate = config.sample_rate;
6893 audio_format_t reqFormat = config.format;
6894 audio_channel_mask_t reqChannels = config.channel_mask;
6895 audio_stream_in_t *inStream = NULL;
Dima Zavin799a70e2011-04-18 16:57:27 -07006896 audio_hw_device_t *inHwDev;
Mathias Agopian65ab4712010-07-14 17:59:35 -07006897
6898 if (pDevices == NULL || *pDevices == 0) {
6899 return 0;
6900 }
Dima Zavin799a70e2011-04-18 16:57:27 -07006901
Mathias Agopian65ab4712010-07-14 17:59:35 -07006902 Mutex::Autolock _l(mLock);
6903
Eric Laurenta4c5a552012-03-29 10:12:40 -07006904 inHwDev = findSuitableHwDev_l(module, *pDevices);
Dima Zavin799a70e2011-04-18 16:57:27 -07006905 if (inHwDev == NULL)
6906 return 0;
6907
Eric Laurentf7ffb8b2012-04-14 09:06:57 -07006908 audio_io_handle_t id = nextUniqueId();
6909
6910 status = inHwDev->open_input_stream(inHwDev, id, *pDevices, &config,
Dima Zavin799a70e2011-04-18 16:57:27 -07006911 &inStream);
Eric Laurenta4c5a552012-03-29 10:12:40 -07006912 ALOGV("openInput() openInputStream returned input %p, SamplingRate %d, Format %d, Channels %x, status %d",
Dima Zavin799a70e2011-04-18 16:57:27 -07006913 inStream,
Eric Laurentf7ffb8b2012-04-14 09:06:57 -07006914 config.sample_rate,
6915 config.format,
6916 config.channel_mask,
Mathias Agopian65ab4712010-07-14 17:59:35 -07006917 status);
6918
6919 // If the input could not be opened with the requested parameters and we can handle the conversion internally,
6920 // try to open again with the proposed parameters. The AudioFlinger can resample the input and do mono to stereo
6921 // or stereo to mono conversions on 16 bit PCM inputs.
Eric Laurentf7ffb8b2012-04-14 09:06:57 -07006922 if (status == BAD_VALUE &&
6923 reqFormat == config.format && config.format == AUDIO_FORMAT_PCM_16_BIT &&
6924 (config.sample_rate <= 2 * reqSamplingRate) &&
6925 (popcount(config.channel_mask) <= FCC_2) && (popcount(reqChannels) <= FCC_2)) {
Steve Block3856b092011-10-20 11:56:00 +01006926 ALOGV("openInput() reopening with proposed sampling rate and channels");
Eric Laurentf7ffb8b2012-04-14 09:06:57 -07006927 inStream = NULL;
6928 status = inHwDev->open_input_stream(inHwDev, id, *pDevices, &config, &inStream);
Mathias Agopian65ab4712010-07-14 17:59:35 -07006929 }
6930
Eric Laurentf7ffb8b2012-04-14 09:06:57 -07006931 if (status == NO_ERROR && inStream != NULL) {
Dima Zavin799a70e2011-04-18 16:57:27 -07006932 AudioStreamIn *input = new AudioStreamIn(inHwDev, inStream);
6933
Eric Laurent7c7f10b2011-06-17 21:29:58 -07006934 // Start record thread
6935 // RecorThread require both input and output device indication to forward to audio
6936 // pre processing modules
6937 uint32_t device = (*pDevices) | primaryOutputDevice_l();
6938 thread = new RecordThread(this,
6939 input,
6940 reqSamplingRate,
6941 reqChannels,
6942 id,
6943 device);
Mathias Agopian65ab4712010-07-14 17:59:35 -07006944 mRecordThreads.add(id, thread);
Steve Block3856b092011-10-20 11:56:00 +01006945 ALOGV("openInput() created record thread: ID %d thread %p", id, thread);
Glenn Kastena0d68332012-01-27 16:47:15 -08006946 if (pSamplingRate != NULL) *pSamplingRate = reqSamplingRate;
Eric Laurentf7ffb8b2012-04-14 09:06:57 -07006947 if (pFormat != NULL) *pFormat = config.format;
Eric Laurenta4c5a552012-03-29 10:12:40 -07006948 if (pChannelMask != NULL) *pChannelMask = reqChannels;
Mathias Agopian65ab4712010-07-14 17:59:35 -07006949
Dima Zavin799a70e2011-04-18 16:57:27 -07006950 input->stream->common.standby(&input->stream->common);
Mathias Agopian65ab4712010-07-14 17:59:35 -07006951
6952 // notify client processes of the new input creation
6953 thread->audioConfigChanged_l(AudioSystem::INPUT_OPENED);
6954 return id;
6955 }
6956
6957 return 0;
6958}
6959
Glenn Kasten72ef00d2012-01-17 11:09:42 -08006960status_t AudioFlinger::closeInput(audio_io_handle_t input)
Mathias Agopian65ab4712010-07-14 17:59:35 -07006961{
6962 // keep strong reference on the record thread so that
6963 // it is not destroyed while exit() is executed
Glenn Kastene53b9ea2012-03-12 16:29:55 -07006964 sp<RecordThread> thread;
Mathias Agopian65ab4712010-07-14 17:59:35 -07006965 {
6966 Mutex::Autolock _l(mLock);
6967 thread = checkRecordThread_l(input);
6968 if (thread == NULL) {
6969 return BAD_VALUE;
6970 }
6971
Steve Block3856b092011-10-20 11:56:00 +01006972 ALOGV("closeInput() %d", input);
Glenn Kastena1117922012-01-26 10:53:32 -08006973 audioConfigChanged_l(AudioSystem::INPUT_CLOSED, input, NULL);
Mathias Agopian65ab4712010-07-14 17:59:35 -07006974 mRecordThreads.removeItem(input);
6975 }
6976 thread->exit();
Glenn Kastenb28686f2012-01-06 08:39:38 -08006977 // The thread entity (active unit of execution) is no longer running here,
6978 // but the ThreadBase container still exists.
Mathias Agopian65ab4712010-07-14 17:59:35 -07006979
Eric Laurentb8ba0a92011-08-07 16:32:26 -07006980 AudioStreamIn *in = thread->clearInput();
Glenn Kasten5798d4e2012-03-08 12:18:35 -08006981 ALOG_ASSERT(in != NULL, "in shouldn't be NULL");
Eric Laurentb8ba0a92011-08-07 16:32:26 -07006982 // from now on thread->mInput is NULL
Dima Zavin799a70e2011-04-18 16:57:27 -07006983 in->hwDev->close_input_stream(in->hwDev, in->stream);
6984 delete in;
Mathias Agopian65ab4712010-07-14 17:59:35 -07006985
6986 return NO_ERROR;
6987}
6988
Glenn Kasten72ef00d2012-01-17 11:09:42 -08006989status_t AudioFlinger::setStreamOutput(audio_stream_type_t stream, audio_io_handle_t output)
Mathias Agopian65ab4712010-07-14 17:59:35 -07006990{
6991 Mutex::Autolock _l(mLock);
6992 MixerThread *dstThread = checkMixerThread_l(output);
6993 if (dstThread == NULL) {
Steve Block5ff1dd52012-01-05 23:22:43 +00006994 ALOGW("setStreamOutput() bad output id %d", output);
Mathias Agopian65ab4712010-07-14 17:59:35 -07006995 return BAD_VALUE;
6996 }
6997
Steve Block3856b092011-10-20 11:56:00 +01006998 ALOGV("setStreamOutput() stream %d to output %d", stream, output);
Mathias Agopian65ab4712010-07-14 17:59:35 -07006999 audioConfigChanged_l(AudioSystem::STREAM_CONFIG_CHANGED, output, &stream);
7000
7001 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
7002 PlaybackThread *thread = mPlaybackThreads.valueAt(i).get();
Glenn Kastena1117922012-01-26 10:53:32 -08007003 if (thread != dstThread && thread->type() != ThreadBase::DIRECT) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07007004 MixerThread *srcThread = (MixerThread *)thread;
7005 srcThread->invalidateTracks(stream);
Mathias Agopian65ab4712010-07-14 17:59:35 -07007006 }
Eric Laurentde070132010-07-13 04:45:46 -07007007 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07007008
7009 return NO_ERROR;
7010}
7011
7012
7013int AudioFlinger::newAudioSessionId()
7014{
Eric Laurent7c7f10b2011-06-17 21:29:58 -07007015 return nextUniqueId();
Mathias Agopian65ab4712010-07-14 17:59:35 -07007016}
7017
Marco Nelissen3a34bef2011-08-02 13:33:41 -07007018void AudioFlinger::acquireAudioSessionId(int audioSession)
7019{
7020 Mutex::Autolock _l(mLock);
Glenn Kastenbb001922012-02-03 11:10:26 -08007021 pid_t caller = IPCThreadState::self()->getCallingPid();
Steve Block3856b092011-10-20 11:56:00 +01007022 ALOGV("acquiring %d from %d", audioSession, caller);
Glenn Kasten8d6a2442012-02-08 14:04:28 -08007023 size_t num = mAudioSessionRefs.size();
7024 for (size_t i = 0; i< num; i++) {
Marco Nelissen3a34bef2011-08-02 13:33:41 -07007025 AudioSessionRef *ref = mAudioSessionRefs.editItemAt(i);
Glenn Kasten012ca6b2012-03-06 11:22:01 -08007026 if (ref->mSessionid == audioSession && ref->mPid == caller) {
7027 ref->mCnt++;
7028 ALOGV(" incremented refcount to %d", ref->mCnt);
Marco Nelissen3a34bef2011-08-02 13:33:41 -07007029 return;
7030 }
7031 }
Glenn Kasten84afa3b2012-01-25 15:28:08 -08007032 mAudioSessionRefs.push(new AudioSessionRef(audioSession, caller));
7033 ALOGV(" added new entry for %d", audioSession);
Marco Nelissen3a34bef2011-08-02 13:33:41 -07007034}
7035
7036void AudioFlinger::releaseAudioSessionId(int audioSession)
7037{
7038 Mutex::Autolock _l(mLock);
Glenn Kastenbb001922012-02-03 11:10:26 -08007039 pid_t caller = IPCThreadState::self()->getCallingPid();
Steve Block3856b092011-10-20 11:56:00 +01007040 ALOGV("releasing %d from %d", audioSession, caller);
Glenn Kasten8d6a2442012-02-08 14:04:28 -08007041 size_t num = mAudioSessionRefs.size();
7042 for (size_t i = 0; i< num; i++) {
Marco Nelissen3a34bef2011-08-02 13:33:41 -07007043 AudioSessionRef *ref = mAudioSessionRefs.itemAt(i);
Glenn Kasten012ca6b2012-03-06 11:22:01 -08007044 if (ref->mSessionid == audioSession && ref->mPid == caller) {
7045 ref->mCnt--;
7046 ALOGV(" decremented refcount to %d", ref->mCnt);
7047 if (ref->mCnt == 0) {
Marco Nelissen3a34bef2011-08-02 13:33:41 -07007048 mAudioSessionRefs.removeAt(i);
7049 delete ref;
7050 purgeStaleEffects_l();
7051 }
7052 return;
7053 }
7054 }
Steve Block5ff1dd52012-01-05 23:22:43 +00007055 ALOGW("session id %d not found for pid %d", audioSession, caller);
Marco Nelissen3a34bef2011-08-02 13:33:41 -07007056}
7057
7058void AudioFlinger::purgeStaleEffects_l() {
7059
Steve Block3856b092011-10-20 11:56:00 +01007060 ALOGV("purging stale effects");
Marco Nelissen3a34bef2011-08-02 13:33:41 -07007061
7062 Vector< sp<EffectChain> > chains;
7063
7064 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
7065 sp<PlaybackThread> t = mPlaybackThreads.valueAt(i);
7066 for (size_t j = 0; j < t->mEffectChains.size(); j++) {
7067 sp<EffectChain> ec = t->mEffectChains[j];
Marco Nelissen0270b182011-08-12 14:14:39 -07007068 if (ec->sessionId() > AUDIO_SESSION_OUTPUT_MIX) {
7069 chains.push(ec);
7070 }
Marco Nelissen3a34bef2011-08-02 13:33:41 -07007071 }
7072 }
7073 for (size_t i = 0; i < mRecordThreads.size(); i++) {
7074 sp<RecordThread> t = mRecordThreads.valueAt(i);
7075 for (size_t j = 0; j < t->mEffectChains.size(); j++) {
7076 sp<EffectChain> ec = t->mEffectChains[j];
7077 chains.push(ec);
7078 }
7079 }
7080
7081 for (size_t i = 0; i < chains.size(); i++) {
7082 sp<EffectChain> ec = chains[i];
7083 int sessionid = ec->sessionId();
7084 sp<ThreadBase> t = ec->mThread.promote();
7085 if (t == 0) {
7086 continue;
7087 }
7088 size_t numsessionrefs = mAudioSessionRefs.size();
7089 bool found = false;
7090 for (size_t k = 0; k < numsessionrefs; k++) {
7091 AudioSessionRef *ref = mAudioSessionRefs.itemAt(k);
Glenn Kasten012ca6b2012-03-06 11:22:01 -08007092 if (ref->mSessionid == sessionid) {
Steve Block3856b092011-10-20 11:56:00 +01007093 ALOGV(" session %d still exists for %d with %d refs",
Glenn Kastene53b9ea2012-03-12 16:29:55 -07007094 sessionid, ref->mPid, ref->mCnt);
Marco Nelissen3a34bef2011-08-02 13:33:41 -07007095 found = true;
7096 break;
7097 }
7098 }
7099 if (!found) {
7100 // remove all effects from the chain
7101 while (ec->mEffects.size()) {
7102 sp<EffectModule> effect = ec->mEffects[0];
7103 effect->unPin();
7104 Mutex::Autolock _l (t->mLock);
7105 t->removeEffect_l(effect);
7106 for (size_t j = 0; j < effect->mHandles.size(); j++) {
7107 sp<EffectHandle> handle = effect->mHandles[j].promote();
7108 if (handle != 0) {
7109 handle->mEffect.clear();
Eric Laurenta85a74a2011-10-19 11:44:54 -07007110 if (handle->mHasControl && handle->mEnabled) {
7111 t->checkSuspendOnEffectEnabled_l(effect, false, effect->sessionId());
7112 }
Marco Nelissen3a34bef2011-08-02 13:33:41 -07007113 }
7114 }
7115 AudioSystem::unregisterEffect(effect->id());
7116 }
7117 }
7118 }
7119 return;
7120}
7121
Mathias Agopian65ab4712010-07-14 17:59:35 -07007122// checkPlaybackThread_l() must be called with AudioFlinger::mLock held
Glenn Kasten72ef00d2012-01-17 11:09:42 -08007123AudioFlinger::PlaybackThread *AudioFlinger::checkPlaybackThread_l(audio_io_handle_t output) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07007124{
Glenn Kastena1117922012-01-26 10:53:32 -08007125 return mPlaybackThreads.valueFor(output).get();
Mathias Agopian65ab4712010-07-14 17:59:35 -07007126}
7127
7128// checkMixerThread_l() must be called with AudioFlinger::mLock held
Glenn Kasten72ef00d2012-01-17 11:09:42 -08007129AudioFlinger::MixerThread *AudioFlinger::checkMixerThread_l(audio_io_handle_t output) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07007130{
7131 PlaybackThread *thread = checkPlaybackThread_l(output);
Glenn Kastena1117922012-01-26 10:53:32 -08007132 return thread != NULL && thread->type() != ThreadBase::DIRECT ? (MixerThread *) thread : NULL;
Mathias Agopian65ab4712010-07-14 17:59:35 -07007133}
7134
7135// checkRecordThread_l() must be called with AudioFlinger::mLock held
Glenn Kasten72ef00d2012-01-17 11:09:42 -08007136AudioFlinger::RecordThread *AudioFlinger::checkRecordThread_l(audio_io_handle_t input) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07007137{
Glenn Kastena1117922012-01-26 10:53:32 -08007138 return mRecordThreads.valueFor(input).get();
Mathias Agopian65ab4712010-07-14 17:59:35 -07007139}
7140
Eric Laurent7c7f10b2011-06-17 21:29:58 -07007141uint32_t AudioFlinger::nextUniqueId()
Mathias Agopian65ab4712010-07-14 17:59:35 -07007142{
Eric Laurent7c7f10b2011-06-17 21:29:58 -07007143 return android_atomic_inc(&mNextUniqueId);
Mathias Agopian65ab4712010-07-14 17:59:35 -07007144}
7145
Glenn Kasten02fe1bf2012-02-24 15:42:17 -08007146AudioFlinger::PlaybackThread *AudioFlinger::primaryPlaybackThread_l() const
Eric Laurent7c7f10b2011-06-17 21:29:58 -07007147{
7148 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
7149 PlaybackThread *thread = mPlaybackThreads.valueAt(i).get();
Eric Laurentb8ba0a92011-08-07 16:32:26 -07007150 AudioStreamOut *output = thread->getOutput();
7151 if (output != NULL && output->hwDev == mPrimaryHardwareDev) {
Eric Laurent7c7f10b2011-06-17 21:29:58 -07007152 return thread;
7153 }
7154 }
7155 return NULL;
7156}
7157
Glenn Kasten02fe1bf2012-02-24 15:42:17 -08007158uint32_t AudioFlinger::primaryOutputDevice_l() const
Eric Laurent7c7f10b2011-06-17 21:29:58 -07007159{
7160 PlaybackThread *thread = primaryPlaybackThread_l();
7161
7162 if (thread == NULL) {
7163 return 0;
7164 }
7165
7166 return thread->device();
7167}
7168
Eric Laurenta011e352012-03-29 15:51:43 -07007169sp<AudioFlinger::SyncEvent> AudioFlinger::createSyncEvent(AudioSystem::sync_event_t type,
7170 int triggerSession,
7171 int listenerSession,
7172 sync_event_callback_t callBack,
7173 void *cookie)
7174{
7175 Mutex::Autolock _l(mLock);
7176
7177 sp<SyncEvent> event = new SyncEvent(type, triggerSession, listenerSession, callBack, cookie);
7178 status_t playStatus = NAME_NOT_FOUND;
7179 status_t recStatus = NAME_NOT_FOUND;
7180 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
7181 playStatus = mPlaybackThreads.valueAt(i)->setSyncEvent(event);
7182 if (playStatus == NO_ERROR) {
7183 return event;
7184 }
7185 }
7186 for (size_t i = 0; i < mRecordThreads.size(); i++) {
7187 recStatus = mRecordThreads.valueAt(i)->setSyncEvent(event);
7188 if (recStatus == NO_ERROR) {
7189 return event;
7190 }
7191 }
7192 if (playStatus == NAME_NOT_FOUND || recStatus == NAME_NOT_FOUND) {
7193 mPendingSyncEvents.add(event);
7194 } else {
7195 ALOGV("createSyncEvent() invalid event %d", event->type());
7196 event.clear();
7197 }
7198 return event;
7199}
Eric Laurent7c7f10b2011-06-17 21:29:58 -07007200
Mathias Agopian65ab4712010-07-14 17:59:35 -07007201// ----------------------------------------------------------------------------
7202// Effect management
7203// ----------------------------------------------------------------------------
7204
7205
Glenn Kastenf587ba52012-01-26 16:25:10 -08007206status_t AudioFlinger::queryNumberEffects(uint32_t *numEffects) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07007207{
7208 Mutex::Autolock _l(mLock);
7209 return EffectQueryNumberEffects(numEffects);
7210}
7211
Glenn Kastenf587ba52012-01-26 16:25:10 -08007212status_t AudioFlinger::queryEffect(uint32_t index, effect_descriptor_t *descriptor) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07007213{
7214 Mutex::Autolock _l(mLock);
7215 return EffectQueryEffect(index, descriptor);
7216}
7217
Glenn Kasten5e92a782012-01-30 07:40:52 -08007218status_t AudioFlinger::getEffectDescriptor(const effect_uuid_t *pUuid,
Glenn Kastenf587ba52012-01-26 16:25:10 -08007219 effect_descriptor_t *descriptor) const
Mathias Agopian65ab4712010-07-14 17:59:35 -07007220{
7221 Mutex::Autolock _l(mLock);
7222 return EffectGetDescriptor(pUuid, descriptor);
7223}
7224
7225
Mathias Agopian65ab4712010-07-14 17:59:35 -07007226sp<IEffect> AudioFlinger::createEffect(pid_t pid,
7227 effect_descriptor_t *pDesc,
7228 const sp<IEffectClient>& effectClient,
7229 int32_t priority,
Glenn Kasten72ef00d2012-01-17 11:09:42 -08007230 audio_io_handle_t io,
Mathias Agopian65ab4712010-07-14 17:59:35 -07007231 int sessionId,
7232 status_t *status,
7233 int *id,
7234 int *enabled)
7235{
7236 status_t lStatus = NO_ERROR;
7237 sp<EffectHandle> handle;
Mathias Agopian65ab4712010-07-14 17:59:35 -07007238 effect_descriptor_t desc;
Mathias Agopian65ab4712010-07-14 17:59:35 -07007239
Glenn Kasten98ec94c2012-01-25 14:28:29 -08007240 ALOGV("createEffect pid %d, effectClient %p, priority %d, sessionId %d, io %d",
Eric Laurent7c7f10b2011-06-17 21:29:58 -07007241 pid, effectClient.get(), priority, sessionId, io);
Mathias Agopian65ab4712010-07-14 17:59:35 -07007242
7243 if (pDesc == NULL) {
7244 lStatus = BAD_VALUE;
7245 goto Exit;
7246 }
7247
Eric Laurent84e9a102010-09-23 16:10:16 -07007248 // check audio settings permission for global effects
Dima Zavinfce7a472011-04-19 22:30:36 -07007249 if (sessionId == AUDIO_SESSION_OUTPUT_MIX && !settingsAllowed()) {
Eric Laurent84e9a102010-09-23 16:10:16 -07007250 lStatus = PERMISSION_DENIED;
7251 goto Exit;
7252 }
7253
Dima Zavinfce7a472011-04-19 22:30:36 -07007254 // Session AUDIO_SESSION_OUTPUT_STAGE is reserved for output stage effects
Eric Laurent84e9a102010-09-23 16:10:16 -07007255 // that can only be created by audio policy manager (running in same process)
Glenn Kasten44deb052012-02-05 18:09:08 -08007256 if (sessionId == AUDIO_SESSION_OUTPUT_STAGE && getpid_cached != pid) {
Eric Laurent84e9a102010-09-23 16:10:16 -07007257 lStatus = PERMISSION_DENIED;
7258 goto Exit;
7259 }
7260
Eric Laurent7c7f10b2011-06-17 21:29:58 -07007261 if (io == 0) {
Dima Zavinfce7a472011-04-19 22:30:36 -07007262 if (sessionId == AUDIO_SESSION_OUTPUT_STAGE) {
Eric Laurent84e9a102010-09-23 16:10:16 -07007263 // output must be specified by AudioPolicyManager when using session
Dima Zavinfce7a472011-04-19 22:30:36 -07007264 // AUDIO_SESSION_OUTPUT_STAGE
Eric Laurent84e9a102010-09-23 16:10:16 -07007265 lStatus = BAD_VALUE;
7266 goto Exit;
Dima Zavinfce7a472011-04-19 22:30:36 -07007267 } else if (sessionId == AUDIO_SESSION_OUTPUT_MIX) {
Eric Laurent84e9a102010-09-23 16:10:16 -07007268 // if the output returned by getOutputForEffect() is removed before we lock the
Eric Laurent7c7f10b2011-06-17 21:29:58 -07007269 // mutex below, the call to checkPlaybackThread_l(io) below will detect it
Eric Laurent84e9a102010-09-23 16:10:16 -07007270 // and we will exit safely
Eric Laurent7c7f10b2011-06-17 21:29:58 -07007271 io = AudioSystem::getOutputForEffect(&desc);
Eric Laurent84e9a102010-09-23 16:10:16 -07007272 }
7273 }
7274
Mathias Agopian65ab4712010-07-14 17:59:35 -07007275 {
7276 Mutex::Autolock _l(mLock);
7277
Mathias Agopian65ab4712010-07-14 17:59:35 -07007278
7279 if (!EffectIsNullUuid(&pDesc->uuid)) {
7280 // if uuid is specified, request effect descriptor
7281 lStatus = EffectGetDescriptor(&pDesc->uuid, &desc);
7282 if (lStatus < 0) {
Steve Block5ff1dd52012-01-05 23:22:43 +00007283 ALOGW("createEffect() error %d from EffectGetDescriptor", lStatus);
Mathias Agopian65ab4712010-07-14 17:59:35 -07007284 goto Exit;
7285 }
7286 } else {
7287 // if uuid is not specified, look for an available implementation
7288 // of the required type in effect factory
7289 if (EffectIsNullUuid(&pDesc->type)) {
Steve Block5ff1dd52012-01-05 23:22:43 +00007290 ALOGW("createEffect() no effect type");
Mathias Agopian65ab4712010-07-14 17:59:35 -07007291 lStatus = BAD_VALUE;
7292 goto Exit;
7293 }
7294 uint32_t numEffects = 0;
7295 effect_descriptor_t d;
Marco Nelissen3a34bef2011-08-02 13:33:41 -07007296 d.flags = 0; // prevent compiler warning
Mathias Agopian65ab4712010-07-14 17:59:35 -07007297 bool found = false;
7298
7299 lStatus = EffectQueryNumberEffects(&numEffects);
7300 if (lStatus < 0) {
Steve Block5ff1dd52012-01-05 23:22:43 +00007301 ALOGW("createEffect() error %d from EffectQueryNumberEffects", lStatus);
Mathias Agopian65ab4712010-07-14 17:59:35 -07007302 goto Exit;
7303 }
7304 for (uint32_t i = 0; i < numEffects; i++) {
7305 lStatus = EffectQueryEffect(i, &desc);
7306 if (lStatus < 0) {
Steve Block5ff1dd52012-01-05 23:22:43 +00007307 ALOGW("createEffect() error %d from EffectQueryEffect", lStatus);
Mathias Agopian65ab4712010-07-14 17:59:35 -07007308 continue;
7309 }
7310 if (memcmp(&desc.type, &pDesc->type, sizeof(effect_uuid_t)) == 0) {
7311 // If matching type found save effect descriptor. If the session is
7312 // 0 and the effect is not auxiliary, continue enumeration in case
7313 // an auxiliary version of this effect type is available
7314 found = true;
7315 memcpy(&d, &desc, sizeof(effect_descriptor_t));
Dima Zavinfce7a472011-04-19 22:30:36 -07007316 if (sessionId != AUDIO_SESSION_OUTPUT_MIX ||
Mathias Agopian65ab4712010-07-14 17:59:35 -07007317 (desc.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
7318 break;
7319 }
7320 }
7321 }
7322 if (!found) {
7323 lStatus = BAD_VALUE;
Steve Block5ff1dd52012-01-05 23:22:43 +00007324 ALOGW("createEffect() effect not found");
Mathias Agopian65ab4712010-07-14 17:59:35 -07007325 goto Exit;
7326 }
7327 // For same effect type, chose auxiliary version over insert version if
7328 // connect to output mix (Compliance to OpenSL ES)
Dima Zavinfce7a472011-04-19 22:30:36 -07007329 if (sessionId == AUDIO_SESSION_OUTPUT_MIX &&
Mathias Agopian65ab4712010-07-14 17:59:35 -07007330 (d.flags & EFFECT_FLAG_TYPE_MASK) != EFFECT_FLAG_TYPE_AUXILIARY) {
7331 memcpy(&desc, &d, sizeof(effect_descriptor_t));
7332 }
7333 }
7334
7335 // Do not allow auxiliary effects on a session different from 0 (output mix)
Dima Zavinfce7a472011-04-19 22:30:36 -07007336 if (sessionId != AUDIO_SESSION_OUTPUT_MIX &&
Mathias Agopian65ab4712010-07-14 17:59:35 -07007337 (desc.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
7338 lStatus = INVALID_OPERATION;
7339 goto Exit;
7340 }
7341
Eric Laurent59255e42011-07-27 19:49:51 -07007342 // check recording permission for visualizer
7343 if ((memcmp(&desc.type, SL_IID_VISUALIZATION, sizeof(effect_uuid_t)) == 0) &&
7344 !recordingAllowed()) {
7345 lStatus = PERMISSION_DENIED;
7346 goto Exit;
7347 }
7348
Mathias Agopian65ab4712010-07-14 17:59:35 -07007349 // return effect descriptor
7350 memcpy(pDesc, &desc, sizeof(effect_descriptor_t));
7351
7352 // If output is not specified try to find a matching audio session ID in one of the
7353 // output threads.
Eric Laurent84e9a102010-09-23 16:10:16 -07007354 // If output is 0 here, sessionId is neither SESSION_OUTPUT_STAGE nor SESSION_OUTPUT_MIX
7355 // because of code checking output when entering the function.
Eric Laurent7c7f10b2011-06-17 21:29:58 -07007356 // Note: io is never 0 when creating an effect on an input
7357 if (io == 0) {
Glenn Kastene53b9ea2012-03-12 16:29:55 -07007358 // look for the thread where the specified audio session is present
Eric Laurent84e9a102010-09-23 16:10:16 -07007359 for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
7360 if (mPlaybackThreads.valueAt(i)->hasAudioSession(sessionId) != 0) {
Eric Laurent7c7f10b2011-06-17 21:29:58 -07007361 io = mPlaybackThreads.keyAt(i);
Eric Laurent84e9a102010-09-23 16:10:16 -07007362 break;
Eric Laurent39e94f82010-07-28 01:32:47 -07007363 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07007364 }
Eric Laurent7c7f10b2011-06-17 21:29:58 -07007365 if (io == 0) {
Glenn Kastene53b9ea2012-03-12 16:29:55 -07007366 for (size_t i = 0; i < mRecordThreads.size(); i++) {
7367 if (mRecordThreads.valueAt(i)->hasAudioSession(sessionId) != 0) {
7368 io = mRecordThreads.keyAt(i);
7369 break;
7370 }
7371 }
Eric Laurent7c7f10b2011-06-17 21:29:58 -07007372 }
Eric Laurent84e9a102010-09-23 16:10:16 -07007373 // If no output thread contains the requested session ID, default to
7374 // first output. The effect chain will be moved to the correct output
7375 // thread when a track with the same session ID is created
Eric Laurent7c7f10b2011-06-17 21:29:58 -07007376 if (io == 0 && mPlaybackThreads.size()) {
7377 io = mPlaybackThreads.keyAt(0);
7378 }
Steve Block3856b092011-10-20 11:56:00 +01007379 ALOGV("createEffect() got io %d for effect %s", io, desc.name);
Eric Laurent7c7f10b2011-06-17 21:29:58 -07007380 }
7381 ThreadBase *thread = checkRecordThread_l(io);
7382 if (thread == NULL) {
7383 thread = checkPlaybackThread_l(io);
7384 if (thread == NULL) {
Steve Block29357bc2012-01-06 19:20:56 +00007385 ALOGE("createEffect() unknown output thread");
Eric Laurent7c7f10b2011-06-17 21:29:58 -07007386 lStatus = BAD_VALUE;
7387 goto Exit;
Eric Laurent84e9a102010-09-23 16:10:16 -07007388 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07007389 }
Eric Laurent84e9a102010-09-23 16:10:16 -07007390
Glenn Kasten98ec94c2012-01-25 14:28:29 -08007391 sp<Client> client = registerPid_l(pid);
Mathias Agopian65ab4712010-07-14 17:59:35 -07007392
Marco Nelissen3a34bef2011-08-02 13:33:41 -07007393 // create effect on selected output thread
Eric Laurentde070132010-07-13 04:45:46 -07007394 handle = thread->createEffect_l(client, effectClient, priority, sessionId,
7395 &desc, enabled, &lStatus);
Mathias Agopian65ab4712010-07-14 17:59:35 -07007396 if (handle != 0 && id != NULL) {
7397 *id = handle->id();
7398 }
7399 }
7400
7401Exit:
Glenn Kastene53b9ea2012-03-12 16:29:55 -07007402 if (status != NULL) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07007403 *status = lStatus;
7404 }
7405 return handle;
7406}
7407
Glenn Kasten72ef00d2012-01-17 11:09:42 -08007408status_t AudioFlinger::moveEffects(int sessionId, audio_io_handle_t srcOutput,
7409 audio_io_handle_t dstOutput)
Eric Laurentde070132010-07-13 04:45:46 -07007410{
Steve Block3856b092011-10-20 11:56:00 +01007411 ALOGV("moveEffects() session %d, srcOutput %d, dstOutput %d",
Eric Laurent59255e42011-07-27 19:49:51 -07007412 sessionId, srcOutput, dstOutput);
Eric Laurentde070132010-07-13 04:45:46 -07007413 Mutex::Autolock _l(mLock);
7414 if (srcOutput == dstOutput) {
Steve Block5ff1dd52012-01-05 23:22:43 +00007415 ALOGW("moveEffects() same dst and src outputs %d", dstOutput);
Eric Laurentde070132010-07-13 04:45:46 -07007416 return NO_ERROR;
Mathias Agopian65ab4712010-07-14 17:59:35 -07007417 }
Eric Laurentde070132010-07-13 04:45:46 -07007418 PlaybackThread *srcThread = checkPlaybackThread_l(srcOutput);
7419 if (srcThread == NULL) {
Steve Block5ff1dd52012-01-05 23:22:43 +00007420 ALOGW("moveEffects() bad srcOutput %d", srcOutput);
Eric Laurentde070132010-07-13 04:45:46 -07007421 return BAD_VALUE;
Mathias Agopian65ab4712010-07-14 17:59:35 -07007422 }
Eric Laurentde070132010-07-13 04:45:46 -07007423 PlaybackThread *dstThread = checkPlaybackThread_l(dstOutput);
7424 if (dstThread == NULL) {
Steve Block5ff1dd52012-01-05 23:22:43 +00007425 ALOGW("moveEffects() bad dstOutput %d", dstOutput);
Eric Laurentde070132010-07-13 04:45:46 -07007426 return BAD_VALUE;
7427 }
7428
7429 Mutex::Autolock _dl(dstThread->mLock);
7430 Mutex::Autolock _sl(srcThread->mLock);
Eric Laurent59255e42011-07-27 19:49:51 -07007431 moveEffectChain_l(sessionId, srcThread, dstThread, false);
Eric Laurentde070132010-07-13 04:45:46 -07007432
Mathias Agopian65ab4712010-07-14 17:59:35 -07007433 return NO_ERROR;
7434}
7435
Marco Nelissen3a34bef2011-08-02 13:33:41 -07007436// moveEffectChain_l must be called with both srcThread and dstThread mLocks held
Eric Laurent59255e42011-07-27 19:49:51 -07007437status_t AudioFlinger::moveEffectChain_l(int sessionId,
Eric Laurentde070132010-07-13 04:45:46 -07007438 AudioFlinger::PlaybackThread *srcThread,
Eric Laurent39e94f82010-07-28 01:32:47 -07007439 AudioFlinger::PlaybackThread *dstThread,
7440 bool reRegister)
Eric Laurentde070132010-07-13 04:45:46 -07007441{
Steve Block3856b092011-10-20 11:56:00 +01007442 ALOGV("moveEffectChain_l() session %d from thread %p to thread %p",
Eric Laurent59255e42011-07-27 19:49:51 -07007443 sessionId, srcThread, dstThread);
Eric Laurentde070132010-07-13 04:45:46 -07007444
Eric Laurent59255e42011-07-27 19:49:51 -07007445 sp<EffectChain> chain = srcThread->getEffectChain_l(sessionId);
Eric Laurentde070132010-07-13 04:45:46 -07007446 if (chain == 0) {
Steve Block5ff1dd52012-01-05 23:22:43 +00007447 ALOGW("moveEffectChain_l() effect chain for session %d not on source thread %p",
Eric Laurent59255e42011-07-27 19:49:51 -07007448 sessionId, srcThread);
Eric Laurentde070132010-07-13 04:45:46 -07007449 return INVALID_OPERATION;
7450 }
7451
Eric Laurent39e94f82010-07-28 01:32:47 -07007452 // remove chain first. This is useful only if reconfiguring effect chain on same output thread,
Eric Laurentde070132010-07-13 04:45:46 -07007453 // so that a new chain is created with correct parameters when first effect is added. This is
Eric Laurentec35a142011-10-05 17:42:25 -07007454 // otherwise unnecessary as removeEffect_l() will remove the chain when last effect is
Eric Laurentde070132010-07-13 04:45:46 -07007455 // removed.
7456 srcThread->removeEffectChain_l(chain);
7457
7458 // transfer all effects one by one so that new effect chain is created on new thread with
7459 // correct buffer sizes and audio parameters and effect engines reconfigured accordingly
Glenn Kasten72ef00d2012-01-17 11:09:42 -08007460 audio_io_handle_t dstOutput = dstThread->id();
Eric Laurent39e94f82010-07-28 01:32:47 -07007461 sp<EffectChain> dstChain;
Marco Nelissen3a34bef2011-08-02 13:33:41 -07007462 uint32_t strategy = 0; // prevent compiler warning
Eric Laurentde070132010-07-13 04:45:46 -07007463 sp<EffectModule> effect = chain->getEffectFromId_l(0);
7464 while (effect != 0) {
7465 srcThread->removeEffect_l(effect);
7466 dstThread->addEffect_l(effect);
Eric Laurentec35a142011-10-05 17:42:25 -07007467 // removeEffect_l() has stopped the effect if it was active so it must be restarted
7468 if (effect->state() == EffectModule::ACTIVE ||
7469 effect->state() == EffectModule::STOPPING) {
7470 effect->start();
7471 }
Eric Laurent39e94f82010-07-28 01:32:47 -07007472 // if the move request is not received from audio policy manager, the effect must be
7473 // re-registered with the new strategy and output
7474 if (dstChain == 0) {
7475 dstChain = effect->chain().promote();
7476 if (dstChain == 0) {
Steve Block5ff1dd52012-01-05 23:22:43 +00007477 ALOGW("moveEffectChain_l() cannot get chain from effect %p", effect.get());
Eric Laurent39e94f82010-07-28 01:32:47 -07007478 srcThread->addEffect_l(effect);
7479 return NO_INIT;
7480 }
7481 strategy = dstChain->strategy();
7482 }
7483 if (reRegister) {
7484 AudioSystem::unregisterEffect(effect->id());
7485 AudioSystem::registerEffect(&effect->desc(),
7486 dstOutput,
7487 strategy,
Eric Laurent59255e42011-07-27 19:49:51 -07007488 sessionId,
Eric Laurent39e94f82010-07-28 01:32:47 -07007489 effect->id());
7490 }
Eric Laurentde070132010-07-13 04:45:46 -07007491 effect = chain->getEffectFromId_l(0);
7492 }
7493
7494 return NO_ERROR;
Mathias Agopian65ab4712010-07-14 17:59:35 -07007495}
7496
Eric Laurent7c7f10b2011-06-17 21:29:58 -07007497
Mathias Agopian65ab4712010-07-14 17:59:35 -07007498// PlaybackThread::createEffect_l() must be called with AudioFlinger::mLock held
Eric Laurent7c7f10b2011-06-17 21:29:58 -07007499sp<AudioFlinger::EffectHandle> AudioFlinger::ThreadBase::createEffect_l(
Mathias Agopian65ab4712010-07-14 17:59:35 -07007500 const sp<AudioFlinger::Client>& client,
7501 const sp<IEffectClient>& effectClient,
7502 int32_t priority,
7503 int sessionId,
7504 effect_descriptor_t *desc,
7505 int *enabled,
7506 status_t *status
7507 )
7508{
7509 sp<EffectModule> effect;
7510 sp<EffectHandle> handle;
7511 status_t lStatus;
Mathias Agopian65ab4712010-07-14 17:59:35 -07007512 sp<EffectChain> chain;
Eric Laurentde070132010-07-13 04:45:46 -07007513 bool chainCreated = false;
Mathias Agopian65ab4712010-07-14 17:59:35 -07007514 bool effectCreated = false;
7515 bool effectRegistered = false;
7516
Eric Laurent7c7f10b2011-06-17 21:29:58 -07007517 lStatus = initCheck();
7518 if (lStatus != NO_ERROR) {
Steve Block5ff1dd52012-01-05 23:22:43 +00007519 ALOGW("createEffect_l() Audio driver not initialized.");
Mathias Agopian65ab4712010-07-14 17:59:35 -07007520 goto Exit;
7521 }
7522
7523 // Do not allow effects with session ID 0 on direct output or duplicating threads
7524 // TODO: add rule for hw accelerated effects on direct outputs with non PCM format
Dima Zavinfce7a472011-04-19 22:30:36 -07007525 if (sessionId == AUDIO_SESSION_OUTPUT_MIX && mType != MIXER) {
Steve Block5ff1dd52012-01-05 23:22:43 +00007526 ALOGW("createEffect_l() Cannot add auxiliary effect %s to session %d",
Eric Laurentde070132010-07-13 04:45:46 -07007527 desc->name, sessionId);
Mathias Agopian65ab4712010-07-14 17:59:35 -07007528 lStatus = BAD_VALUE;
7529 goto Exit;
7530 }
Eric Laurent7c7f10b2011-06-17 21:29:58 -07007531 // Only Pre processor effects are allowed on input threads and only on input threads
Glenn Kastena1117922012-01-26 10:53:32 -08007532 if ((mType == RECORD) != ((desc->flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_PRE_PROC)) {
Steve Block5ff1dd52012-01-05 23:22:43 +00007533 ALOGW("createEffect_l() effect %s (flags %08x) created on wrong thread type %d",
Eric Laurent7c7f10b2011-06-17 21:29:58 -07007534 desc->name, desc->flags, mType);
7535 lStatus = BAD_VALUE;
7536 goto Exit;
7537 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07007538
Steve Block3856b092011-10-20 11:56:00 +01007539 ALOGV("createEffect_l() thread %p effect %s on session %d", this, desc->name, sessionId);
Mathias Agopian65ab4712010-07-14 17:59:35 -07007540
7541 { // scope for mLock
7542 Mutex::Autolock _l(mLock);
7543
7544 // check for existing effect chain with the requested audio session
7545 chain = getEffectChain_l(sessionId);
7546 if (chain == 0) {
7547 // create a new chain for this session
Steve Block3856b092011-10-20 11:56:00 +01007548 ALOGV("createEffect_l() new effect chain for session %d", sessionId);
Mathias Agopian65ab4712010-07-14 17:59:35 -07007549 chain = new EffectChain(this, sessionId);
7550 addEffectChain_l(chain);
Eric Laurentde070132010-07-13 04:45:46 -07007551 chain->setStrategy(getStrategyForSession_l(sessionId));
7552 chainCreated = true;
Mathias Agopian65ab4712010-07-14 17:59:35 -07007553 } else {
Eric Laurentcab11242010-07-15 12:50:15 -07007554 effect = chain->getEffectFromDesc_l(desc);
Mathias Agopian65ab4712010-07-14 17:59:35 -07007555 }
7556
Glenn Kasten7fc9a6f2012-01-10 10:46:34 -08007557 ALOGV("createEffect_l() got effect %p on chain %p", effect.get(), chain.get());
Mathias Agopian65ab4712010-07-14 17:59:35 -07007558
7559 if (effect == 0) {
Eric Laurent7c7f10b2011-06-17 21:29:58 -07007560 int id = mAudioFlinger->nextUniqueId();
Mathias Agopian65ab4712010-07-14 17:59:35 -07007561 // Check CPU and memory usage
Eric Laurentde070132010-07-13 04:45:46 -07007562 lStatus = AudioSystem::registerEffect(desc, mId, chain->strategy(), sessionId, id);
Mathias Agopian65ab4712010-07-14 17:59:35 -07007563 if (lStatus != NO_ERROR) {
7564 goto Exit;
7565 }
7566 effectRegistered = true;
7567 // create a new effect module if none present in the chain
Eric Laurentde070132010-07-13 04:45:46 -07007568 effect = new EffectModule(this, chain, desc, id, sessionId);
Mathias Agopian65ab4712010-07-14 17:59:35 -07007569 lStatus = effect->status();
7570 if (lStatus != NO_ERROR) {
7571 goto Exit;
7572 }
Eric Laurentcab11242010-07-15 12:50:15 -07007573 lStatus = chain->addEffect_l(effect);
Mathias Agopian65ab4712010-07-14 17:59:35 -07007574 if (lStatus != NO_ERROR) {
7575 goto Exit;
7576 }
7577 effectCreated = true;
7578
7579 effect->setDevice(mDevice);
7580 effect->setMode(mAudioFlinger->getMode());
7581 }
7582 // create effect handle and connect it to effect module
7583 handle = new EffectHandle(effect, client, effectClient, priority);
7584 lStatus = effect->addHandle(handle);
Glenn Kastena0d68332012-01-27 16:47:15 -08007585 if (enabled != NULL) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07007586 *enabled = (int)effect->isEnabled();
7587 }
7588 }
7589
7590Exit:
7591 if (lStatus != NO_ERROR && lStatus != ALREADY_EXISTS) {
Eric Laurentde070132010-07-13 04:45:46 -07007592 Mutex::Autolock _l(mLock);
Mathias Agopian65ab4712010-07-14 17:59:35 -07007593 if (effectCreated) {
Eric Laurentde070132010-07-13 04:45:46 -07007594 chain->removeEffect_l(effect);
Mathias Agopian65ab4712010-07-14 17:59:35 -07007595 }
7596 if (effectRegistered) {
Eric Laurentde070132010-07-13 04:45:46 -07007597 AudioSystem::unregisterEffect(effect->id());
7598 }
7599 if (chainCreated) {
7600 removeEffectChain_l(chain);
Mathias Agopian65ab4712010-07-14 17:59:35 -07007601 }
7602 handle.clear();
7603 }
7604
Glenn Kastene53b9ea2012-03-12 16:29:55 -07007605 if (status != NULL) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07007606 *status = lStatus;
7607 }
7608 return handle;
7609}
7610
Eric Laurent7c7f10b2011-06-17 21:29:58 -07007611sp<AudioFlinger::EffectModule> AudioFlinger::ThreadBase::getEffect_l(int sessionId, int effectId)
7612{
Eric Laurent7c7f10b2011-06-17 21:29:58 -07007613 sp<EffectChain> chain = getEffectChain_l(sessionId);
Glenn Kasten090f0192012-01-30 13:00:02 -08007614 return chain != 0 ? chain->getEffectFromId_l(effectId) : 0;
Eric Laurent7c7f10b2011-06-17 21:29:58 -07007615}
7616
Eric Laurentde070132010-07-13 04:45:46 -07007617// PlaybackThread::addEffect_l() must be called with AudioFlinger::mLock and
7618// PlaybackThread::mLock held
Eric Laurent7c7f10b2011-06-17 21:29:58 -07007619status_t AudioFlinger::ThreadBase::addEffect_l(const sp<EffectModule>& effect)
Eric Laurentde070132010-07-13 04:45:46 -07007620{
7621 // check for existing effect chain with the requested audio session
7622 int sessionId = effect->sessionId();
7623 sp<EffectChain> chain = getEffectChain_l(sessionId);
7624 bool chainCreated = false;
7625
7626 if (chain == 0) {
7627 // create a new chain for this session
Steve Block3856b092011-10-20 11:56:00 +01007628 ALOGV("addEffect_l() new effect chain for session %d", sessionId);
Eric Laurentde070132010-07-13 04:45:46 -07007629 chain = new EffectChain(this, sessionId);
7630 addEffectChain_l(chain);
7631 chain->setStrategy(getStrategyForSession_l(sessionId));
7632 chainCreated = true;
7633 }
Steve Block3856b092011-10-20 11:56:00 +01007634 ALOGV("addEffect_l() %p chain %p effect %p", this, chain.get(), effect.get());
Eric Laurentde070132010-07-13 04:45:46 -07007635
7636 if (chain->getEffectFromId_l(effect->id()) != 0) {
Steve Block5ff1dd52012-01-05 23:22:43 +00007637 ALOGW("addEffect_l() %p effect %s already present in chain %p",
Eric Laurentde070132010-07-13 04:45:46 -07007638 this, effect->desc().name, chain.get());
7639 return BAD_VALUE;
7640 }
7641
7642 status_t status = chain->addEffect_l(effect);
7643 if (status != NO_ERROR) {
7644 if (chainCreated) {
7645 removeEffectChain_l(chain);
7646 }
7647 return status;
7648 }
7649
7650 effect->setDevice(mDevice);
7651 effect->setMode(mAudioFlinger->getMode());
7652 return NO_ERROR;
7653}
7654
Eric Laurent7c7f10b2011-06-17 21:29:58 -07007655void AudioFlinger::ThreadBase::removeEffect_l(const sp<EffectModule>& effect) {
Eric Laurentde070132010-07-13 04:45:46 -07007656
Steve Block3856b092011-10-20 11:56:00 +01007657 ALOGV("removeEffect_l() %p effect %p", this, effect.get());
Mathias Agopian65ab4712010-07-14 17:59:35 -07007658 effect_descriptor_t desc = effect->desc();
Eric Laurentde070132010-07-13 04:45:46 -07007659 if ((desc.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
7660 detachAuxEffect_l(effect->id());
7661 }
7662
7663 sp<EffectChain> chain = effect->chain().promote();
7664 if (chain != 0) {
7665 // remove effect chain if removing last effect
7666 if (chain->removeEffect_l(effect) == 0) {
7667 removeEffectChain_l(chain);
7668 }
7669 } else {
Steve Block5ff1dd52012-01-05 23:22:43 +00007670 ALOGW("removeEffect_l() %p cannot promote chain for effect %p", this, effect.get());
Eric Laurentde070132010-07-13 04:45:46 -07007671 }
7672}
7673
Eric Laurent7c7f10b2011-06-17 21:29:58 -07007674void AudioFlinger::ThreadBase::lockEffectChains_l(
Glenn Kastene53b9ea2012-03-12 16:29:55 -07007675 Vector< sp<AudioFlinger::EffectChain> >& effectChains)
Eric Laurent7c7f10b2011-06-17 21:29:58 -07007676{
7677 effectChains = mEffectChains;
7678 for (size_t i = 0; i < mEffectChains.size(); i++) {
7679 mEffectChains[i]->lock();
7680 }
7681}
7682
7683void AudioFlinger::ThreadBase::unlockEffectChains(
Glenn Kastene53b9ea2012-03-12 16:29:55 -07007684 const Vector< sp<AudioFlinger::EffectChain> >& effectChains)
Eric Laurent7c7f10b2011-06-17 21:29:58 -07007685{
7686 for (size_t i = 0; i < effectChains.size(); i++) {
7687 effectChains[i]->unlock();
7688 }
7689}
7690
7691sp<AudioFlinger::EffectChain> AudioFlinger::ThreadBase::getEffectChain(int sessionId)
7692{
7693 Mutex::Autolock _l(mLock);
7694 return getEffectChain_l(sessionId);
7695}
7696
7697sp<AudioFlinger::EffectChain> AudioFlinger::ThreadBase::getEffectChain_l(int sessionId)
7698{
Eric Laurent7c7f10b2011-06-17 21:29:58 -07007699 size_t size = mEffectChains.size();
7700 for (size_t i = 0; i < size; i++) {
7701 if (mEffectChains[i]->sessionId() == sessionId) {
Glenn Kasten090f0192012-01-30 13:00:02 -08007702 return mEffectChains[i];
Eric Laurent7c7f10b2011-06-17 21:29:58 -07007703 }
7704 }
Glenn Kasten090f0192012-01-30 13:00:02 -08007705 return 0;
Eric Laurent7c7f10b2011-06-17 21:29:58 -07007706}
7707
Glenn Kastenf78aee72012-01-04 11:00:47 -08007708void AudioFlinger::ThreadBase::setMode(audio_mode_t mode)
Eric Laurent7c7f10b2011-06-17 21:29:58 -07007709{
7710 Mutex::Autolock _l(mLock);
7711 size_t size = mEffectChains.size();
7712 for (size_t i = 0; i < size; i++) {
7713 mEffectChains[i]->setMode_l(mode);
7714 }
7715}
7716
7717void AudioFlinger::ThreadBase::disconnectEffect(const sp<EffectModule>& effect,
Marco Nelissen3a34bef2011-08-02 13:33:41 -07007718 const wp<EffectHandle>& handle,
Glenn Kasten58123c32012-02-03 10:32:24 -08007719 bool unpinIfLast) {
Eric Laurent59255e42011-07-27 19:49:51 -07007720
Mathias Agopian65ab4712010-07-14 17:59:35 -07007721 Mutex::Autolock _l(mLock);
Steve Block3856b092011-10-20 11:56:00 +01007722 ALOGV("disconnectEffect() %p effect %p", this, effect.get());
Mathias Agopian65ab4712010-07-14 17:59:35 -07007723 // delete the effect module if removing last handle on it
7724 if (effect->removeHandle(handle) == 0) {
Glenn Kasten58123c32012-02-03 10:32:24 -08007725 if (!effect->isPinned() || unpinIfLast) {
Marco Nelissen3a34bef2011-08-02 13:33:41 -07007726 removeEffect_l(effect);
7727 AudioSystem::unregisterEffect(effect->id());
7728 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07007729 }
7730}
7731
7732status_t AudioFlinger::PlaybackThread::addEffectChain_l(const sp<EffectChain>& chain)
7733{
7734 int session = chain->sessionId();
7735 int16_t *buffer = mMixBuffer;
7736 bool ownsBuffer = false;
7737
Steve Block3856b092011-10-20 11:56:00 +01007738 ALOGV("addEffectChain_l() %p on thread %p for session %d", chain.get(), this, session);
Mathias Agopian65ab4712010-07-14 17:59:35 -07007739 if (session > 0) {
7740 // Only one effect chain can be present in direct output thread and it uses
7741 // the mix buffer as input
7742 if (mType != DIRECT) {
Glenn Kasten58912562012-04-03 10:45:00 -07007743 size_t numSamples = mNormalFrameCount * mChannelCount;
Mathias Agopian65ab4712010-07-14 17:59:35 -07007744 buffer = new int16_t[numSamples];
7745 memset(buffer, 0, numSamples * sizeof(int16_t));
Steve Block3856b092011-10-20 11:56:00 +01007746 ALOGV("addEffectChain_l() creating new input buffer %p session %d", buffer, session);
Mathias Agopian65ab4712010-07-14 17:59:35 -07007747 ownsBuffer = true;
7748 }
7749
7750 // Attach all tracks with same session ID to this chain.
7751 for (size_t i = 0; i < mTracks.size(); ++i) {
7752 sp<Track> track = mTracks[i];
7753 if (session == track->sessionId()) {
Steve Block3856b092011-10-20 11:56:00 +01007754 ALOGV("addEffectChain_l() track->setMainBuffer track %p buffer %p", track.get(), buffer);
Mathias Agopian65ab4712010-07-14 17:59:35 -07007755 track->setMainBuffer(buffer);
Eric Laurentb469b942011-05-09 12:09:06 -07007756 chain->incTrackCnt();
Mathias Agopian65ab4712010-07-14 17:59:35 -07007757 }
7758 }
7759
7760 // indicate all active tracks in the chain
7761 for (size_t i = 0 ; i < mActiveTracks.size() ; ++i) {
7762 sp<Track> track = mActiveTracks[i].promote();
7763 if (track == 0) continue;
7764 if (session == track->sessionId()) {
Steve Block3856b092011-10-20 11:56:00 +01007765 ALOGV("addEffectChain_l() activating track %p on session %d", track.get(), session);
Eric Laurentb469b942011-05-09 12:09:06 -07007766 chain->incActiveTrackCnt();
Mathias Agopian65ab4712010-07-14 17:59:35 -07007767 }
7768 }
7769 }
7770
7771 chain->setInBuffer(buffer, ownsBuffer);
7772 chain->setOutBuffer(mMixBuffer);
Dima Zavinfce7a472011-04-19 22:30:36 -07007773 // Effect chain for session AUDIO_SESSION_OUTPUT_STAGE is inserted at end of effect
Eric Laurentde070132010-07-13 04:45:46 -07007774 // chains list in order to be processed last as it contains output stage effects
Dima Zavinfce7a472011-04-19 22:30:36 -07007775 // Effect chain for session AUDIO_SESSION_OUTPUT_MIX is inserted before
7776 // session AUDIO_SESSION_OUTPUT_STAGE to be processed
Mathias Agopian65ab4712010-07-14 17:59:35 -07007777 // after track specific effects and before output stage
Dima Zavinfce7a472011-04-19 22:30:36 -07007778 // It is therefore mandatory that AUDIO_SESSION_OUTPUT_MIX == 0 and
7779 // that AUDIO_SESSION_OUTPUT_STAGE < AUDIO_SESSION_OUTPUT_MIX
Eric Laurentde070132010-07-13 04:45:46 -07007780 // Effect chain for other sessions are inserted at beginning of effect
7781 // chains list to be processed before output mix effects. Relative order between other
7782 // sessions is not important
Mathias Agopian65ab4712010-07-14 17:59:35 -07007783 size_t size = mEffectChains.size();
7784 size_t i = 0;
7785 for (i = 0; i < size; i++) {
7786 if (mEffectChains[i]->sessionId() < session) break;
7787 }
7788 mEffectChains.insertAt(chain, i);
Eric Laurent59255e42011-07-27 19:49:51 -07007789 checkSuspendOnAddEffectChain_l(chain);
Mathias Agopian65ab4712010-07-14 17:59:35 -07007790
7791 return NO_ERROR;
7792}
7793
7794size_t AudioFlinger::PlaybackThread::removeEffectChain_l(const sp<EffectChain>& chain)
7795{
7796 int session = chain->sessionId();
7797
Steve Block3856b092011-10-20 11:56:00 +01007798 ALOGV("removeEffectChain_l() %p from thread %p for session %d", chain.get(), this, session);
Mathias Agopian65ab4712010-07-14 17:59:35 -07007799
7800 for (size_t i = 0; i < mEffectChains.size(); i++) {
7801 if (chain == mEffectChains[i]) {
7802 mEffectChains.removeAt(i);
Eric Laurentb469b942011-05-09 12:09:06 -07007803 // detach all active tracks from the chain
7804 for (size_t i = 0 ; i < mActiveTracks.size() ; ++i) {
7805 sp<Track> track = mActiveTracks[i].promote();
7806 if (track == 0) continue;
7807 if (session == track->sessionId()) {
Steve Block3856b092011-10-20 11:56:00 +01007808 ALOGV("removeEffectChain_l(): stopping track on chain %p for session Id: %d",
Eric Laurentb469b942011-05-09 12:09:06 -07007809 chain.get(), session);
7810 chain->decActiveTrackCnt();
7811 }
7812 }
7813
Mathias Agopian65ab4712010-07-14 17:59:35 -07007814 // detach all tracks with same session ID from this chain
7815 for (size_t i = 0; i < mTracks.size(); ++i) {
7816 sp<Track> track = mTracks[i];
7817 if (session == track->sessionId()) {
7818 track->setMainBuffer(mMixBuffer);
Eric Laurentb469b942011-05-09 12:09:06 -07007819 chain->decTrackCnt();
Mathias Agopian65ab4712010-07-14 17:59:35 -07007820 }
7821 }
Eric Laurentde070132010-07-13 04:45:46 -07007822 break;
Mathias Agopian65ab4712010-07-14 17:59:35 -07007823 }
7824 }
7825 return mEffectChains.size();
7826}
7827
Eric Laurentde070132010-07-13 04:45:46 -07007828status_t AudioFlinger::PlaybackThread::attachAuxEffect(
7829 const sp<AudioFlinger::PlaybackThread::Track> track, int EffectId)
Mathias Agopian65ab4712010-07-14 17:59:35 -07007830{
7831 Mutex::Autolock _l(mLock);
7832 return attachAuxEffect_l(track, EffectId);
7833}
7834
Eric Laurentde070132010-07-13 04:45:46 -07007835status_t AudioFlinger::PlaybackThread::attachAuxEffect_l(
7836 const sp<AudioFlinger::PlaybackThread::Track> track, int EffectId)
Mathias Agopian65ab4712010-07-14 17:59:35 -07007837{
7838 status_t status = NO_ERROR;
7839
7840 if (EffectId == 0) {
7841 track->setAuxBuffer(0, NULL);
7842 } else {
Dima Zavinfce7a472011-04-19 22:30:36 -07007843 // Auxiliary effects are always in audio session AUDIO_SESSION_OUTPUT_MIX
7844 sp<EffectModule> effect = getEffect_l(AUDIO_SESSION_OUTPUT_MIX, EffectId);
Mathias Agopian65ab4712010-07-14 17:59:35 -07007845 if (effect != 0) {
7846 if ((effect->desc().flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
7847 track->setAuxBuffer(EffectId, (int32_t *)effect->inBuffer());
7848 } else {
7849 status = INVALID_OPERATION;
7850 }
7851 } else {
7852 status = BAD_VALUE;
7853 }
7854 }
7855 return status;
7856}
7857
7858void AudioFlinger::PlaybackThread::detachAuxEffect_l(int effectId)
7859{
Glenn Kastene53b9ea2012-03-12 16:29:55 -07007860 for (size_t i = 0; i < mTracks.size(); ++i) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07007861 sp<Track> track = mTracks[i];
7862 if (track->auxEffectId() == effectId) {
7863 attachAuxEffect_l(track, 0);
7864 }
7865 }
7866}
7867
Eric Laurent7c7f10b2011-06-17 21:29:58 -07007868status_t AudioFlinger::RecordThread::addEffectChain_l(const sp<EffectChain>& chain)
7869{
7870 // only one chain per input thread
7871 if (mEffectChains.size() != 0) {
7872 return INVALID_OPERATION;
7873 }
Steve Block3856b092011-10-20 11:56:00 +01007874 ALOGV("addEffectChain_l() %p on thread %p", chain.get(), this);
Eric Laurent7c7f10b2011-06-17 21:29:58 -07007875
7876 chain->setInBuffer(NULL);
7877 chain->setOutBuffer(NULL);
7878
Eric Laurent59255e42011-07-27 19:49:51 -07007879 checkSuspendOnAddEffectChain_l(chain);
7880
Eric Laurent7c7f10b2011-06-17 21:29:58 -07007881 mEffectChains.add(chain);
7882
7883 return NO_ERROR;
7884}
7885
7886size_t AudioFlinger::RecordThread::removeEffectChain_l(const sp<EffectChain>& chain)
7887{
Steve Block3856b092011-10-20 11:56:00 +01007888 ALOGV("removeEffectChain_l() %p from thread %p", chain.get(), this);
Steve Block5ff1dd52012-01-05 23:22:43 +00007889 ALOGW_IF(mEffectChains.size() != 1,
Eric Laurent7c7f10b2011-06-17 21:29:58 -07007890 "removeEffectChain_l() %p invalid chain size %d on thread %p",
7891 chain.get(), mEffectChains.size(), this);
7892 if (mEffectChains.size() == 1) {
7893 mEffectChains.removeAt(0);
7894 }
7895 return 0;
7896}
7897
Mathias Agopian65ab4712010-07-14 17:59:35 -07007898// ----------------------------------------------------------------------------
7899// EffectModule implementation
7900// ----------------------------------------------------------------------------
7901
7902#undef LOG_TAG
7903#define LOG_TAG "AudioFlinger::EffectModule"
7904
Glenn Kasten9eaa5572012-01-20 13:32:16 -08007905AudioFlinger::EffectModule::EffectModule(ThreadBase *thread,
Mathias Agopian65ab4712010-07-14 17:59:35 -07007906 const wp<AudioFlinger::EffectChain>& chain,
7907 effect_descriptor_t *desc,
7908 int id,
7909 int sessionId)
Glenn Kasten9eaa5572012-01-20 13:32:16 -08007910 : mThread(thread), mChain(chain), mId(id), mSessionId(sessionId), mEffectInterface(NULL),
Eric Laurent59255e42011-07-27 19:49:51 -07007911 mStatus(NO_INIT), mState(IDLE), mSuspended(false)
Mathias Agopian65ab4712010-07-14 17:59:35 -07007912{
Steve Block3856b092011-10-20 11:56:00 +01007913 ALOGV("Constructor %p", this);
Mathias Agopian65ab4712010-07-14 17:59:35 -07007914 int lStatus;
Glenn Kasten9eaa5572012-01-20 13:32:16 -08007915 if (thread == NULL) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07007916 return;
7917 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07007918
7919 memcpy(&mDescriptor, desc, sizeof(effect_descriptor_t));
7920
7921 // create effect engine from effect factory
Eric Laurent7c7f10b2011-06-17 21:29:58 -07007922 mStatus = EffectCreate(&desc->uuid, sessionId, thread->id(), &mEffectInterface);
Mathias Agopian65ab4712010-07-14 17:59:35 -07007923
7924 if (mStatus != NO_ERROR) {
7925 return;
7926 }
7927 lStatus = init();
7928 if (lStatus < 0) {
7929 mStatus = lStatus;
7930 goto Error;
7931 }
7932
Marco Nelissen3a34bef2011-08-02 13:33:41 -07007933 if (mSessionId > AUDIO_SESSION_OUTPUT_MIX) {
7934 mPinned = true;
7935 }
Steve Block3856b092011-10-20 11:56:00 +01007936 ALOGV("Constructor success name %s, Interface %p", mDescriptor.name, mEffectInterface);
Mathias Agopian65ab4712010-07-14 17:59:35 -07007937 return;
7938Error:
7939 EffectRelease(mEffectInterface);
7940 mEffectInterface = NULL;
Steve Block3856b092011-10-20 11:56:00 +01007941 ALOGV("Constructor Error %d", mStatus);
Mathias Agopian65ab4712010-07-14 17:59:35 -07007942}
7943
7944AudioFlinger::EffectModule::~EffectModule()
7945{
Steve Block3856b092011-10-20 11:56:00 +01007946 ALOGV("Destructor %p", this);
Mathias Agopian65ab4712010-07-14 17:59:35 -07007947 if (mEffectInterface != NULL) {
Eric Laurent7c7f10b2011-06-17 21:29:58 -07007948 if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_PRE_PROC ||
7949 (mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_POST_PROC) {
7950 sp<ThreadBase> thread = mThread.promote();
7951 if (thread != 0) {
Eric Laurentb8ba0a92011-08-07 16:32:26 -07007952 audio_stream_t *stream = thread->stream();
7953 if (stream != NULL) {
7954 stream->remove_audio_effect(stream, mEffectInterface);
7955 }
Eric Laurent7c7f10b2011-06-17 21:29:58 -07007956 }
7957 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07007958 // release effect engine
7959 EffectRelease(mEffectInterface);
7960 }
7961}
7962
Glenn Kasten435dbe62012-01-30 10:15:48 -08007963status_t AudioFlinger::EffectModule::addHandle(const sp<EffectHandle>& handle)
Mathias Agopian65ab4712010-07-14 17:59:35 -07007964{
7965 status_t status;
7966
7967 Mutex::Autolock _l(mLock);
Mathias Agopian65ab4712010-07-14 17:59:35 -07007968 int priority = handle->priority();
7969 size_t size = mHandles.size();
7970 sp<EffectHandle> h;
7971 size_t i;
7972 for (i = 0; i < size; i++) {
7973 h = mHandles[i].promote();
7974 if (h == 0) continue;
7975 if (h->priority() <= priority) break;
7976 }
7977 // if inserted in first place, move effect control from previous owner to this handle
7978 if (i == 0) {
Eric Laurent59255e42011-07-27 19:49:51 -07007979 bool enabled = false;
Mathias Agopian65ab4712010-07-14 17:59:35 -07007980 if (h != 0) {
Eric Laurent59255e42011-07-27 19:49:51 -07007981 enabled = h->enabled();
7982 h->setControl(false/*hasControl*/, true /*signal*/, enabled /*enabled*/);
Mathias Agopian65ab4712010-07-14 17:59:35 -07007983 }
Eric Laurent59255e42011-07-27 19:49:51 -07007984 handle->setControl(true /*hasControl*/, false /*signal*/, enabled /*enabled*/);
Mathias Agopian65ab4712010-07-14 17:59:35 -07007985 status = NO_ERROR;
7986 } else {
7987 status = ALREADY_EXISTS;
7988 }
Steve Block3856b092011-10-20 11:56:00 +01007989 ALOGV("addHandle() %p added handle %p in position %d", this, handle.get(), i);
Mathias Agopian65ab4712010-07-14 17:59:35 -07007990 mHandles.insertAt(handle, i);
7991 return status;
7992}
7993
7994size_t AudioFlinger::EffectModule::removeHandle(const wp<EffectHandle>& handle)
7995{
7996 Mutex::Autolock _l(mLock);
7997 size_t size = mHandles.size();
7998 size_t i;
7999 for (i = 0; i < size; i++) {
8000 if (mHandles[i] == handle) break;
8001 }
8002 if (i == size) {
8003 return size;
8004 }
Steve Block3856b092011-10-20 11:56:00 +01008005 ALOGV("removeHandle() %p removed handle %p in position %d", this, handle.unsafe_get(), i);
Eric Laurent59255e42011-07-27 19:49:51 -07008006
8007 bool enabled = false;
8008 EffectHandle *hdl = handle.unsafe_get();
Glenn Kastena0d68332012-01-27 16:47:15 -08008009 if (hdl != NULL) {
Steve Block3856b092011-10-20 11:56:00 +01008010 ALOGV("removeHandle() unsafe_get OK");
Eric Laurent59255e42011-07-27 19:49:51 -07008011 enabled = hdl->enabled();
8012 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07008013 mHandles.removeAt(i);
8014 size = mHandles.size();
8015 // if removed from first place, move effect control from this handle to next in line
8016 if (i == 0 && size != 0) {
8017 sp<EffectHandle> h = mHandles[0].promote();
8018 if (h != 0) {
Eric Laurent59255e42011-07-27 19:49:51 -07008019 h->setControl(true /*hasControl*/, true /*signal*/ , enabled /*enabled*/);
Mathias Agopian65ab4712010-07-14 17:59:35 -07008020 }
8021 }
8022
Eric Laurentec437d82011-07-26 20:54:46 -07008023 // Prevent calls to process() and other functions on effect interface from now on.
8024 // The effect engine will be released by the destructor when the last strong reference on
8025 // this object is released which can happen after next process is called.
Marco Nelissen3a34bef2011-08-02 13:33:41 -07008026 if (size == 0 && !mPinned) {
Eric Laurentec437d82011-07-26 20:54:46 -07008027 mState = DESTROYED;
Eric Laurentdac69112010-09-28 14:09:57 -07008028 }
8029
Mathias Agopian65ab4712010-07-14 17:59:35 -07008030 return size;
8031}
8032
Eric Laurent59255e42011-07-27 19:49:51 -07008033sp<AudioFlinger::EffectHandle> AudioFlinger::EffectModule::controlHandle()
8034{
8035 Mutex::Autolock _l(mLock);
Glenn Kasten090f0192012-01-30 13:00:02 -08008036 return mHandles.size() != 0 ? mHandles[0].promote() : 0;
Eric Laurent59255e42011-07-27 19:49:51 -07008037}
8038
Glenn Kasten58123c32012-02-03 10:32:24 -08008039void AudioFlinger::EffectModule::disconnect(const wp<EffectHandle>& handle, bool unpinIfLast)
Mathias Agopian65ab4712010-07-14 17:59:35 -07008040{
Glenn Kasten90bebef2012-01-27 15:24:38 -08008041 ALOGV("disconnect() %p handle %p", this, handle.unsafe_get());
Mathias Agopian65ab4712010-07-14 17:59:35 -07008042 // keep a strong reference on this EffectModule to avoid calling the
8043 // destructor before we exit
8044 sp<EffectModule> keep(this);
8045 {
8046 sp<ThreadBase> thread = mThread.promote();
8047 if (thread != 0) {
Glenn Kasten58123c32012-02-03 10:32:24 -08008048 thread->disconnectEffect(keep, handle, unpinIfLast);
Mathias Agopian65ab4712010-07-14 17:59:35 -07008049 }
8050 }
8051}
8052
8053void AudioFlinger::EffectModule::updateState() {
8054 Mutex::Autolock _l(mLock);
8055
8056 switch (mState) {
8057 case RESTART:
8058 reset_l();
8059 // FALL THROUGH
8060
8061 case STARTING:
8062 // clear auxiliary effect input buffer for next accumulation
8063 if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
8064 memset(mConfig.inputCfg.buffer.raw,
8065 0,
8066 mConfig.inputCfg.buffer.frameCount*sizeof(int32_t));
8067 }
8068 start_l();
8069 mState = ACTIVE;
8070 break;
8071 case STOPPING:
8072 stop_l();
8073 mDisableWaitCnt = mMaxDisableWaitCnt;
8074 mState = STOPPED;
8075 break;
8076 case STOPPED:
8077 // mDisableWaitCnt is forced to 1 by process() when the engine indicates the end of the
8078 // turn off sequence.
8079 if (--mDisableWaitCnt == 0) {
8080 reset_l();
8081 mState = IDLE;
8082 }
8083 break;
Eric Laurentec437d82011-07-26 20:54:46 -07008084 default: //IDLE , ACTIVE, DESTROYED
Mathias Agopian65ab4712010-07-14 17:59:35 -07008085 break;
8086 }
8087}
8088
8089void AudioFlinger::EffectModule::process()
8090{
8091 Mutex::Autolock _l(mLock);
8092
Eric Laurentec437d82011-07-26 20:54:46 -07008093 if (mState == DESTROYED || mEffectInterface == NULL ||
Mathias Agopian65ab4712010-07-14 17:59:35 -07008094 mConfig.inputCfg.buffer.raw == NULL ||
8095 mConfig.outputCfg.buffer.raw == NULL) {
8096 return;
8097 }
8098
Eric Laurent8f45bd72010-08-31 13:50:07 -07008099 if (isProcessEnabled()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07008100 // do 32 bit to 16 bit conversion for auxiliary effect input buffer
8101 if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
Glenn Kasten3b21c502011-12-15 09:52:39 -08008102 ditherAndClamp(mConfig.inputCfg.buffer.s32,
Mathias Agopian65ab4712010-07-14 17:59:35 -07008103 mConfig.inputCfg.buffer.s32,
Eric Laurentde070132010-07-13 04:45:46 -07008104 mConfig.inputCfg.buffer.frameCount/2);
Mathias Agopian65ab4712010-07-14 17:59:35 -07008105 }
8106
8107 // do the actual processing in the effect engine
8108 int ret = (*mEffectInterface)->process(mEffectInterface,
8109 &mConfig.inputCfg.buffer,
8110 &mConfig.outputCfg.buffer);
8111
8112 // force transition to IDLE state when engine is ready
8113 if (mState == STOPPED && ret == -ENODATA) {
8114 mDisableWaitCnt = 1;
8115 }
8116
8117 // clear auxiliary effect input buffer for next accumulation
8118 if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
Eric Laurent73337482011-01-19 18:36:13 -08008119 memset(mConfig.inputCfg.buffer.raw, 0,
8120 mConfig.inputCfg.buffer.frameCount*sizeof(int32_t));
Mathias Agopian65ab4712010-07-14 17:59:35 -07008121 }
8122 } else if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_INSERT &&
Eric Laurent73337482011-01-19 18:36:13 -08008123 mConfig.inputCfg.buffer.raw != mConfig.outputCfg.buffer.raw) {
8124 // If an insert effect is idle and input buffer is different from output buffer,
8125 // accumulate input onto output
Mathias Agopian65ab4712010-07-14 17:59:35 -07008126 sp<EffectChain> chain = mChain.promote();
Eric Laurentb469b942011-05-09 12:09:06 -07008127 if (chain != 0 && chain->activeTrackCnt() != 0) {
Eric Laurent73337482011-01-19 18:36:13 -08008128 size_t frameCnt = mConfig.inputCfg.buffer.frameCount * 2; //always stereo here
8129 int16_t *in = mConfig.inputCfg.buffer.s16;
8130 int16_t *out = mConfig.outputCfg.buffer.s16;
8131 for (size_t i = 0; i < frameCnt; i++) {
8132 out[i] = clamp16((int32_t)out[i] + (int32_t)in[i]);
Mathias Agopian65ab4712010-07-14 17:59:35 -07008133 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07008134 }
8135 }
8136}
8137
8138void AudioFlinger::EffectModule::reset_l()
8139{
8140 if (mEffectInterface == NULL) {
8141 return;
8142 }
8143 (*mEffectInterface)->command(mEffectInterface, EFFECT_CMD_RESET, 0, NULL, 0, NULL);
8144}
8145
8146status_t AudioFlinger::EffectModule::configure()
8147{
8148 uint32_t channels;
8149 if (mEffectInterface == NULL) {
8150 return NO_INIT;
8151 }
8152
8153 sp<ThreadBase> thread = mThread.promote();
8154 if (thread == 0) {
8155 return DEAD_OBJECT;
8156 }
8157
8158 // TODO: handle configuration of effects replacing track process
8159 if (thread->channelCount() == 1) {
Eric Laurente1315cf2011-05-17 19:16:02 -07008160 channels = AUDIO_CHANNEL_OUT_MONO;
Mathias Agopian65ab4712010-07-14 17:59:35 -07008161 } else {
Eric Laurente1315cf2011-05-17 19:16:02 -07008162 channels = AUDIO_CHANNEL_OUT_STEREO;
Mathias Agopian65ab4712010-07-14 17:59:35 -07008163 }
8164
8165 if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
Eric Laurente1315cf2011-05-17 19:16:02 -07008166 mConfig.inputCfg.channels = AUDIO_CHANNEL_OUT_MONO;
Mathias Agopian65ab4712010-07-14 17:59:35 -07008167 } else {
8168 mConfig.inputCfg.channels = channels;
8169 }
8170 mConfig.outputCfg.channels = channels;
Eric Laurente1315cf2011-05-17 19:16:02 -07008171 mConfig.inputCfg.format = AUDIO_FORMAT_PCM_16_BIT;
8172 mConfig.outputCfg.format = AUDIO_FORMAT_PCM_16_BIT;
Mathias Agopian65ab4712010-07-14 17:59:35 -07008173 mConfig.inputCfg.samplingRate = thread->sampleRate();
8174 mConfig.outputCfg.samplingRate = mConfig.inputCfg.samplingRate;
8175 mConfig.inputCfg.bufferProvider.cookie = NULL;
8176 mConfig.inputCfg.bufferProvider.getBuffer = NULL;
8177 mConfig.inputCfg.bufferProvider.releaseBuffer = NULL;
8178 mConfig.outputCfg.bufferProvider.cookie = NULL;
8179 mConfig.outputCfg.bufferProvider.getBuffer = NULL;
8180 mConfig.outputCfg.bufferProvider.releaseBuffer = NULL;
8181 mConfig.inputCfg.accessMode = EFFECT_BUFFER_ACCESS_READ;
8182 // Insert effect:
Dima Zavinfce7a472011-04-19 22:30:36 -07008183 // - in session AUDIO_SESSION_OUTPUT_MIX or AUDIO_SESSION_OUTPUT_STAGE,
Eric Laurentde070132010-07-13 04:45:46 -07008184 // always overwrites output buffer: input buffer == output buffer
Mathias Agopian65ab4712010-07-14 17:59:35 -07008185 // - in other sessions:
8186 // last effect in the chain accumulates in output buffer: input buffer != output buffer
8187 // other effect: overwrites output buffer: input buffer == output buffer
8188 // Auxiliary effect:
8189 // accumulates in output buffer: input buffer != output buffer
8190 // Therefore: accumulate <=> input buffer != output buffer
8191 if (mConfig.inputCfg.buffer.raw != mConfig.outputCfg.buffer.raw) {
8192 mConfig.outputCfg.accessMode = EFFECT_BUFFER_ACCESS_ACCUMULATE;
8193 } else {
8194 mConfig.outputCfg.accessMode = EFFECT_BUFFER_ACCESS_WRITE;
8195 }
8196 mConfig.inputCfg.mask = EFFECT_CONFIG_ALL;
8197 mConfig.outputCfg.mask = EFFECT_CONFIG_ALL;
8198 mConfig.inputCfg.buffer.frameCount = thread->frameCount();
8199 mConfig.outputCfg.buffer.frameCount = mConfig.inputCfg.buffer.frameCount;
8200
Steve Block3856b092011-10-20 11:56:00 +01008201 ALOGV("configure() %p thread %p buffer %p framecount %d",
Eric Laurentde070132010-07-13 04:45:46 -07008202 this, thread.get(), mConfig.inputCfg.buffer.raw, mConfig.inputCfg.buffer.frameCount);
8203
Mathias Agopian65ab4712010-07-14 17:59:35 -07008204 status_t cmdStatus;
Eric Laurent25f43952010-07-28 05:40:18 -07008205 uint32_t size = sizeof(int);
8206 status_t status = (*mEffectInterface)->command(mEffectInterface,
Eric Laurent3d5188b2011-12-16 15:30:36 -08008207 EFFECT_CMD_SET_CONFIG,
Eric Laurent25f43952010-07-28 05:40:18 -07008208 sizeof(effect_config_t),
8209 &mConfig,
8210 &size,
8211 &cmdStatus);
Mathias Agopian65ab4712010-07-14 17:59:35 -07008212 if (status == 0) {
8213 status = cmdStatus;
8214 }
8215
Marco Nelissenf06c2ed2012-06-06 09:52:31 -07008216 if (status == 0 &&
8217 (memcmp(&mDescriptor.type, SL_IID_VISUALIZATION, sizeof(effect_uuid_t)) == 0)) {
8218 uint32_t buf32[sizeof(effect_param_t) / sizeof(uint32_t) + 2];
8219 effect_param_t *p = (effect_param_t *)buf32;
8220
8221 p->psize = sizeof(uint32_t);
8222 p->vsize = sizeof(uint32_t);
8223 size = sizeof(int);
8224 *(int32_t *)p->data = VISUALIZER_PARAM_LATENCY;
8225
8226 uint32_t latency = 0;
8227 PlaybackThread *pbt = thread->mAudioFlinger->checkPlaybackThread_l(thread->mId);
8228 if (pbt != NULL) {
8229 latency = pbt->latency_l();
8230 }
8231
8232 *((int32_t *)p->data + 1)= latency;
8233 (*mEffectInterface)->command(mEffectInterface,
8234 EFFECT_CMD_SET_PARAM,
8235 sizeof(effect_param_t) + 8,
8236 &buf32,
8237 &size,
8238 &cmdStatus);
8239 }
8240
Mathias Agopian65ab4712010-07-14 17:59:35 -07008241 mMaxDisableWaitCnt = (MAX_DISABLE_TIME_MS * mConfig.outputCfg.samplingRate) /
8242 (1000 * mConfig.outputCfg.buffer.frameCount);
8243
8244 return status;
8245}
8246
8247status_t AudioFlinger::EffectModule::init()
8248{
8249 Mutex::Autolock _l(mLock);
8250 if (mEffectInterface == NULL) {
8251 return NO_INIT;
8252 }
8253 status_t cmdStatus;
Eric Laurent25f43952010-07-28 05:40:18 -07008254 uint32_t size = sizeof(status_t);
8255 status_t status = (*mEffectInterface)->command(mEffectInterface,
8256 EFFECT_CMD_INIT,
8257 0,
8258 NULL,
8259 &size,
8260 &cmdStatus);
Mathias Agopian65ab4712010-07-14 17:59:35 -07008261 if (status == 0) {
8262 status = cmdStatus;
8263 }
8264 return status;
8265}
8266
Eric Laurentec35a142011-10-05 17:42:25 -07008267status_t AudioFlinger::EffectModule::start()
8268{
8269 Mutex::Autolock _l(mLock);
8270 return start_l();
8271}
8272
Mathias Agopian65ab4712010-07-14 17:59:35 -07008273status_t AudioFlinger::EffectModule::start_l()
8274{
8275 if (mEffectInterface == NULL) {
8276 return NO_INIT;
8277 }
8278 status_t cmdStatus;
Eric Laurent25f43952010-07-28 05:40:18 -07008279 uint32_t size = sizeof(status_t);
8280 status_t status = (*mEffectInterface)->command(mEffectInterface,
8281 EFFECT_CMD_ENABLE,
8282 0,
8283 NULL,
8284 &size,
8285 &cmdStatus);
Mathias Agopian65ab4712010-07-14 17:59:35 -07008286 if (status == 0) {
8287 status = cmdStatus;
8288 }
Eric Laurent7c7f10b2011-06-17 21:29:58 -07008289 if (status == 0 &&
8290 ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_PRE_PROC ||
8291 (mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_POST_PROC)) {
8292 sp<ThreadBase> thread = mThread.promote();
8293 if (thread != 0) {
Eric Laurentb8ba0a92011-08-07 16:32:26 -07008294 audio_stream_t *stream = thread->stream();
8295 if (stream != NULL) {
8296 stream->add_audio_effect(stream, mEffectInterface);
8297 }
Eric Laurent7c7f10b2011-06-17 21:29:58 -07008298 }
8299 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07008300 return status;
8301}
8302
Eric Laurentec437d82011-07-26 20:54:46 -07008303status_t AudioFlinger::EffectModule::stop()
8304{
8305 Mutex::Autolock _l(mLock);
8306 return stop_l();
8307}
8308
Mathias Agopian65ab4712010-07-14 17:59:35 -07008309status_t AudioFlinger::EffectModule::stop_l()
8310{
8311 if (mEffectInterface == NULL) {
8312 return NO_INIT;
8313 }
8314 status_t cmdStatus;
Eric Laurent25f43952010-07-28 05:40:18 -07008315 uint32_t size = sizeof(status_t);
8316 status_t status = (*mEffectInterface)->command(mEffectInterface,
8317 EFFECT_CMD_DISABLE,
8318 0,
8319 NULL,
8320 &size,
8321 &cmdStatus);
Mathias Agopian65ab4712010-07-14 17:59:35 -07008322 if (status == 0) {
8323 status = cmdStatus;
8324 }
Eric Laurent7c7f10b2011-06-17 21:29:58 -07008325 if (status == 0 &&
8326 ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_PRE_PROC ||
8327 (mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_POST_PROC)) {
8328 sp<ThreadBase> thread = mThread.promote();
8329 if (thread != 0) {
Eric Laurentb8ba0a92011-08-07 16:32:26 -07008330 audio_stream_t *stream = thread->stream();
8331 if (stream != NULL) {
8332 stream->remove_audio_effect(stream, mEffectInterface);
8333 }
Eric Laurent7c7f10b2011-06-17 21:29:58 -07008334 }
8335 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07008336 return status;
8337}
8338
Eric Laurent25f43952010-07-28 05:40:18 -07008339status_t AudioFlinger::EffectModule::command(uint32_t cmdCode,
8340 uint32_t cmdSize,
8341 void *pCmdData,
8342 uint32_t *replySize,
8343 void *pReplyData)
Mathias Agopian65ab4712010-07-14 17:59:35 -07008344{
8345 Mutex::Autolock _l(mLock);
Steve Block3856b092011-10-20 11:56:00 +01008346// ALOGV("command(), cmdCode: %d, mEffectInterface: %p", cmdCode, mEffectInterface);
Mathias Agopian65ab4712010-07-14 17:59:35 -07008347
Eric Laurentec437d82011-07-26 20:54:46 -07008348 if (mState == DESTROYED || mEffectInterface == NULL) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07008349 return NO_INIT;
8350 }
Eric Laurent25f43952010-07-28 05:40:18 -07008351 status_t status = (*mEffectInterface)->command(mEffectInterface,
8352 cmdCode,
8353 cmdSize,
8354 pCmdData,
8355 replySize,
8356 pReplyData);
Mathias Agopian65ab4712010-07-14 17:59:35 -07008357 if (cmdCode != EFFECT_CMD_GET_PARAM && status == NO_ERROR) {
Eric Laurent25f43952010-07-28 05:40:18 -07008358 uint32_t size = (replySize == NULL) ? 0 : *replySize;
Mathias Agopian65ab4712010-07-14 17:59:35 -07008359 for (size_t i = 1; i < mHandles.size(); i++) {
8360 sp<EffectHandle> h = mHandles[i].promote();
8361 if (h != 0) {
8362 h->commandExecuted(cmdCode, cmdSize, pCmdData, size, pReplyData);
8363 }
8364 }
8365 }
8366 return status;
8367}
8368
8369status_t AudioFlinger::EffectModule::setEnabled(bool enabled)
8370{
Eric Laurentdb7c0792011-08-10 10:37:50 -07008371
Mathias Agopian65ab4712010-07-14 17:59:35 -07008372 Mutex::Autolock _l(mLock);
Steve Block3856b092011-10-20 11:56:00 +01008373 ALOGV("setEnabled %p enabled %d", this, enabled);
Mathias Agopian65ab4712010-07-14 17:59:35 -07008374
8375 if (enabled != isEnabled()) {
Eric Laurentdb7c0792011-08-10 10:37:50 -07008376 status_t status = AudioSystem::setEffectEnabled(mId, enabled);
8377 if (enabled && status != NO_ERROR) {
8378 return status;
8379 }
8380
Mathias Agopian65ab4712010-07-14 17:59:35 -07008381 switch (mState) {
8382 // going from disabled to enabled
8383 case IDLE:
8384 mState = STARTING;
8385 break;
8386 case STOPPED:
8387 mState = RESTART;
8388 break;
8389 case STOPPING:
8390 mState = ACTIVE;
8391 break;
8392
8393 // going from enabled to disabled
8394 case RESTART:
Eric Laurent8f45bd72010-08-31 13:50:07 -07008395 mState = STOPPED;
8396 break;
Mathias Agopian65ab4712010-07-14 17:59:35 -07008397 case STARTING:
8398 mState = IDLE;
8399 break;
8400 case ACTIVE:
8401 mState = STOPPING;
8402 break;
Eric Laurentec437d82011-07-26 20:54:46 -07008403 case DESTROYED:
8404 return NO_ERROR; // simply ignore as we are being destroyed
Mathias Agopian65ab4712010-07-14 17:59:35 -07008405 }
8406 for (size_t i = 1; i < mHandles.size(); i++) {
8407 sp<EffectHandle> h = mHandles[i].promote();
8408 if (h != 0) {
8409 h->setEnabled(enabled);
8410 }
8411 }
8412 }
8413 return NO_ERROR;
8414}
8415
Glenn Kastenc59c0042012-02-02 14:06:11 -08008416bool AudioFlinger::EffectModule::isEnabled() const
Mathias Agopian65ab4712010-07-14 17:59:35 -07008417{
8418 switch (mState) {
8419 case RESTART:
8420 case STARTING:
8421 case ACTIVE:
8422 return true;
8423 case IDLE:
8424 case STOPPING:
8425 case STOPPED:
Eric Laurentec437d82011-07-26 20:54:46 -07008426 case DESTROYED:
Mathias Agopian65ab4712010-07-14 17:59:35 -07008427 default:
8428 return false;
8429 }
8430}
8431
Glenn Kastenc59c0042012-02-02 14:06:11 -08008432bool AudioFlinger::EffectModule::isProcessEnabled() const
Eric Laurent8f45bd72010-08-31 13:50:07 -07008433{
8434 switch (mState) {
8435 case RESTART:
8436 case ACTIVE:
8437 case STOPPING:
8438 case STOPPED:
8439 return true;
8440 case IDLE:
8441 case STARTING:
Eric Laurentec437d82011-07-26 20:54:46 -07008442 case DESTROYED:
Eric Laurent8f45bd72010-08-31 13:50:07 -07008443 default:
8444 return false;
8445 }
8446}
8447
Mathias Agopian65ab4712010-07-14 17:59:35 -07008448status_t AudioFlinger::EffectModule::setVolume(uint32_t *left, uint32_t *right, bool controller)
8449{
8450 Mutex::Autolock _l(mLock);
8451 status_t status = NO_ERROR;
8452
8453 // Send volume indication if EFFECT_FLAG_VOLUME_IND is set and read back altered volume
8454 // if controller flag is set (Note that controller == TRUE => EFFECT_FLAG_VOLUME_CTRL set)
Eric Laurent8f45bd72010-08-31 13:50:07 -07008455 if (isProcessEnabled() &&
Eric Laurentf997cab2010-07-19 06:24:46 -07008456 ((mDescriptor.flags & EFFECT_FLAG_VOLUME_MASK) == EFFECT_FLAG_VOLUME_CTRL ||
8457 (mDescriptor.flags & EFFECT_FLAG_VOLUME_MASK) == EFFECT_FLAG_VOLUME_IND)) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07008458 status_t cmdStatus;
8459 uint32_t volume[2];
8460 uint32_t *pVolume = NULL;
Eric Laurent25f43952010-07-28 05:40:18 -07008461 uint32_t size = sizeof(volume);
Mathias Agopian65ab4712010-07-14 17:59:35 -07008462 volume[0] = *left;
8463 volume[1] = *right;
8464 if (controller) {
8465 pVolume = volume;
8466 }
Eric Laurent25f43952010-07-28 05:40:18 -07008467 status = (*mEffectInterface)->command(mEffectInterface,
8468 EFFECT_CMD_SET_VOLUME,
8469 size,
8470 volume,
8471 &size,
8472 pVolume);
Mathias Agopian65ab4712010-07-14 17:59:35 -07008473 if (controller && status == NO_ERROR && size == sizeof(volume)) {
8474 *left = volume[0];
8475 *right = volume[1];
8476 }
8477 }
8478 return status;
8479}
8480
8481status_t AudioFlinger::EffectModule::setDevice(uint32_t device)
8482{
8483 Mutex::Autolock _l(mLock);
8484 status_t status = NO_ERROR;
Eric Laurent7c7f10b2011-06-17 21:29:58 -07008485 if (device && (mDescriptor.flags & EFFECT_FLAG_DEVICE_MASK) == EFFECT_FLAG_DEVICE_IND) {
8486 // audio pre processing modules on RecordThread can receive both output and
8487 // input device indication in the same call
8488 uint32_t dev = device & AUDIO_DEVICE_OUT_ALL;
8489 if (dev) {
8490 status_t cmdStatus;
8491 uint32_t size = sizeof(status_t);
8492
8493 status = (*mEffectInterface)->command(mEffectInterface,
8494 EFFECT_CMD_SET_DEVICE,
8495 sizeof(uint32_t),
8496 &dev,
8497 &size,
8498 &cmdStatus);
8499 if (status == NO_ERROR) {
8500 status = cmdStatus;
8501 }
8502 }
8503 dev = device & AUDIO_DEVICE_IN_ALL;
8504 if (dev) {
8505 status_t cmdStatus;
8506 uint32_t size = sizeof(status_t);
8507
8508 status_t status2 = (*mEffectInterface)->command(mEffectInterface,
8509 EFFECT_CMD_SET_INPUT_DEVICE,
8510 sizeof(uint32_t),
8511 &dev,
8512 &size,
8513 &cmdStatus);
8514 if (status2 == NO_ERROR) {
8515 status2 = cmdStatus;
8516 }
8517 if (status == NO_ERROR) {
8518 status = status2;
8519 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07008520 }
8521 }
8522 return status;
8523}
8524
Glenn Kastenf78aee72012-01-04 11:00:47 -08008525status_t AudioFlinger::EffectModule::setMode(audio_mode_t mode)
Mathias Agopian65ab4712010-07-14 17:59:35 -07008526{
8527 Mutex::Autolock _l(mLock);
8528 status_t status = NO_ERROR;
8529 if ((mDescriptor.flags & EFFECT_FLAG_AUDIO_MODE_MASK) == EFFECT_FLAG_AUDIO_MODE_IND) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07008530 status_t cmdStatus;
Eric Laurent25f43952010-07-28 05:40:18 -07008531 uint32_t size = sizeof(status_t);
8532 status = (*mEffectInterface)->command(mEffectInterface,
8533 EFFECT_CMD_SET_AUDIO_MODE,
Glenn Kastenf78aee72012-01-04 11:00:47 -08008534 sizeof(audio_mode_t),
Eric Laurente1315cf2011-05-17 19:16:02 -07008535 &mode,
Eric Laurent25f43952010-07-28 05:40:18 -07008536 &size,
8537 &cmdStatus);
Mathias Agopian65ab4712010-07-14 17:59:35 -07008538 if (status == NO_ERROR) {
8539 status = cmdStatus;
8540 }
8541 }
8542 return status;
8543}
8544
Eric Laurent59255e42011-07-27 19:49:51 -07008545void AudioFlinger::EffectModule::setSuspended(bool suspended)
8546{
8547 Mutex::Autolock _l(mLock);
8548 mSuspended = suspended;
8549}
Glenn Kastena3a85482012-01-04 11:01:11 -08008550
8551bool AudioFlinger::EffectModule::suspended() const
Eric Laurent59255e42011-07-27 19:49:51 -07008552{
8553 Mutex::Autolock _l(mLock);
8554 return mSuspended;
8555}
8556
Mathias Agopian65ab4712010-07-14 17:59:35 -07008557status_t AudioFlinger::EffectModule::dump(int fd, const Vector<String16>& args)
8558{
8559 const size_t SIZE = 256;
8560 char buffer[SIZE];
8561 String8 result;
8562
8563 snprintf(buffer, SIZE, "\tEffect ID %d:\n", mId);
8564 result.append(buffer);
8565
8566 bool locked = tryLock(mLock);
8567 // failed to lock - AudioFlinger is probably deadlocked
8568 if (!locked) {
8569 result.append("\t\tCould not lock Fx mutex:\n");
8570 }
8571
8572 result.append("\t\tSession Status State Engine:\n");
8573 snprintf(buffer, SIZE, "\t\t%05d %03d %03d 0x%08x\n",
8574 mSessionId, mStatus, mState, (uint32_t)mEffectInterface);
8575 result.append(buffer);
8576
8577 result.append("\t\tDescriptor:\n");
8578 snprintf(buffer, SIZE, "\t\t- UUID: %08X-%04X-%04X-%04X-%02X%02X%02X%02X%02X%02X\n",
8579 mDescriptor.uuid.timeLow, mDescriptor.uuid.timeMid, mDescriptor.uuid.timeHiAndVersion,
8580 mDescriptor.uuid.clockSeq, mDescriptor.uuid.node[0], mDescriptor.uuid.node[1],mDescriptor.uuid.node[2],
8581 mDescriptor.uuid.node[3],mDescriptor.uuid.node[4],mDescriptor.uuid.node[5]);
8582 result.append(buffer);
8583 snprintf(buffer, SIZE, "\t\t- TYPE: %08X-%04X-%04X-%04X-%02X%02X%02X%02X%02X%02X\n",
8584 mDescriptor.type.timeLow, mDescriptor.type.timeMid, mDescriptor.type.timeHiAndVersion,
8585 mDescriptor.type.clockSeq, mDescriptor.type.node[0], mDescriptor.type.node[1],mDescriptor.type.node[2],
8586 mDescriptor.type.node[3],mDescriptor.type.node[4],mDescriptor.type.node[5]);
8587 result.append(buffer);
Eric Laurente1315cf2011-05-17 19:16:02 -07008588 snprintf(buffer, SIZE, "\t\t- apiVersion: %08X\n\t\t- flags: %08X\n",
Mathias Agopian65ab4712010-07-14 17:59:35 -07008589 mDescriptor.apiVersion,
8590 mDescriptor.flags);
8591 result.append(buffer);
8592 snprintf(buffer, SIZE, "\t\t- name: %s\n",
8593 mDescriptor.name);
8594 result.append(buffer);
8595 snprintf(buffer, SIZE, "\t\t- implementor: %s\n",
8596 mDescriptor.implementor);
8597 result.append(buffer);
8598
8599 result.append("\t\t- Input configuration:\n");
8600 result.append("\t\t\tBuffer Frames Smp rate Channels Format\n");
8601 snprintf(buffer, SIZE, "\t\t\t0x%08x %05d %05d %08x %d\n",
8602 (uint32_t)mConfig.inputCfg.buffer.raw,
8603 mConfig.inputCfg.buffer.frameCount,
8604 mConfig.inputCfg.samplingRate,
8605 mConfig.inputCfg.channels,
8606 mConfig.inputCfg.format);
8607 result.append(buffer);
8608
8609 result.append("\t\t- Output configuration:\n");
8610 result.append("\t\t\tBuffer Frames Smp rate Channels Format\n");
8611 snprintf(buffer, SIZE, "\t\t\t0x%08x %05d %05d %08x %d\n",
8612 (uint32_t)mConfig.outputCfg.buffer.raw,
8613 mConfig.outputCfg.buffer.frameCount,
8614 mConfig.outputCfg.samplingRate,
8615 mConfig.outputCfg.channels,
8616 mConfig.outputCfg.format);
8617 result.append(buffer);
8618
8619 snprintf(buffer, SIZE, "\t\t%d Clients:\n", mHandles.size());
8620 result.append(buffer);
8621 result.append("\t\t\tPid Priority Ctrl Locked client server\n");
8622 for (size_t i = 0; i < mHandles.size(); ++i) {
8623 sp<EffectHandle> handle = mHandles[i].promote();
8624 if (handle != 0) {
8625 handle->dump(buffer, SIZE);
8626 result.append(buffer);
8627 }
8628 }
8629
8630 result.append("\n");
8631
8632 write(fd, result.string(), result.length());
8633
8634 if (locked) {
8635 mLock.unlock();
8636 }
8637
8638 return NO_ERROR;
8639}
8640
8641// ----------------------------------------------------------------------------
8642// EffectHandle implementation
8643// ----------------------------------------------------------------------------
8644
8645#undef LOG_TAG
8646#define LOG_TAG "AudioFlinger::EffectHandle"
8647
8648AudioFlinger::EffectHandle::EffectHandle(const sp<EffectModule>& effect,
8649 const sp<AudioFlinger::Client>& client,
8650 const sp<IEffectClient>& effectClient,
8651 int32_t priority)
8652 : BnEffect(),
Marco Nelissen3a34bef2011-08-02 13:33:41 -07008653 mEffect(effect), mEffectClient(effectClient), mClient(client), mCblk(NULL),
Eric Laurent59255e42011-07-27 19:49:51 -07008654 mPriority(priority), mHasControl(false), mEnabled(false)
Mathias Agopian65ab4712010-07-14 17:59:35 -07008655{
Steve Block3856b092011-10-20 11:56:00 +01008656 ALOGV("constructor %p", this);
Mathias Agopian65ab4712010-07-14 17:59:35 -07008657
Marco Nelissen3a34bef2011-08-02 13:33:41 -07008658 if (client == 0) {
8659 return;
8660 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07008661 int bufOffset = ((sizeof(effect_param_cblk_t) - 1) / sizeof(int) + 1) * sizeof(int);
8662 mCblkMemory = client->heap()->allocate(EFFECT_PARAM_BUFFER_SIZE + bufOffset);
8663 if (mCblkMemory != 0) {
8664 mCblk = static_cast<effect_param_cblk_t *>(mCblkMemory->pointer());
8665
Glenn Kastena0d68332012-01-27 16:47:15 -08008666 if (mCblk != NULL) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07008667 new(mCblk) effect_param_cblk_t();
8668 mBuffer = (uint8_t *)mCblk + bufOffset;
Glenn Kastene53b9ea2012-03-12 16:29:55 -07008669 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07008670 } else {
Steve Block29357bc2012-01-06 19:20:56 +00008671 ALOGE("not enough memory for Effect size=%u", EFFECT_PARAM_BUFFER_SIZE + sizeof(effect_param_cblk_t));
Mathias Agopian65ab4712010-07-14 17:59:35 -07008672 return;
8673 }
8674}
8675
8676AudioFlinger::EffectHandle::~EffectHandle()
8677{
Steve Block3856b092011-10-20 11:56:00 +01008678 ALOGV("Destructor %p", this);
Marco Nelissen3a34bef2011-08-02 13:33:41 -07008679 disconnect(false);
Steve Block3856b092011-10-20 11:56:00 +01008680 ALOGV("Destructor DONE %p", this);
Mathias Agopian65ab4712010-07-14 17:59:35 -07008681}
8682
8683status_t AudioFlinger::EffectHandle::enable()
8684{
Steve Block3856b092011-10-20 11:56:00 +01008685 ALOGV("enable %p", this);
Mathias Agopian65ab4712010-07-14 17:59:35 -07008686 if (!mHasControl) return INVALID_OPERATION;
8687 if (mEffect == 0) return DEAD_OBJECT;
8688
Eric Laurentdb7c0792011-08-10 10:37:50 -07008689 if (mEnabled) {
8690 return NO_ERROR;
8691 }
8692
Eric Laurent59255e42011-07-27 19:49:51 -07008693 mEnabled = true;
8694
8695 sp<ThreadBase> thread = mEffect->thread().promote();
8696 if (thread != 0) {
8697 thread->checkSuspendOnEffectEnabled(mEffect, true, mEffect->sessionId());
8698 }
8699
8700 // checkSuspendOnEffectEnabled() can suspend this same effect when enabled
8701 if (mEffect->suspended()) {
8702 return NO_ERROR;
8703 }
8704
Eric Laurentdb7c0792011-08-10 10:37:50 -07008705 status_t status = mEffect->setEnabled(true);
8706 if (status != NO_ERROR) {
8707 if (thread != 0) {
8708 thread->checkSuspendOnEffectEnabled(mEffect, false, mEffect->sessionId());
8709 }
8710 mEnabled = false;
8711 }
8712 return status;
Mathias Agopian65ab4712010-07-14 17:59:35 -07008713}
8714
8715status_t AudioFlinger::EffectHandle::disable()
8716{
Steve Block3856b092011-10-20 11:56:00 +01008717 ALOGV("disable %p", this);
Mathias Agopian65ab4712010-07-14 17:59:35 -07008718 if (!mHasControl) return INVALID_OPERATION;
Eric Laurent59255e42011-07-27 19:49:51 -07008719 if (mEffect == 0) return DEAD_OBJECT;
Mathias Agopian65ab4712010-07-14 17:59:35 -07008720
Eric Laurentdb7c0792011-08-10 10:37:50 -07008721 if (!mEnabled) {
8722 return NO_ERROR;
8723 }
Eric Laurent59255e42011-07-27 19:49:51 -07008724 mEnabled = false;
8725
8726 if (mEffect->suspended()) {
8727 return NO_ERROR;
8728 }
8729
8730 status_t status = mEffect->setEnabled(false);
8731
8732 sp<ThreadBase> thread = mEffect->thread().promote();
8733 if (thread != 0) {
8734 thread->checkSuspendOnEffectEnabled(mEffect, false, mEffect->sessionId());
8735 }
8736
8737 return status;
Mathias Agopian65ab4712010-07-14 17:59:35 -07008738}
8739
8740void AudioFlinger::EffectHandle::disconnect()
8741{
Marco Nelissen3a34bef2011-08-02 13:33:41 -07008742 disconnect(true);
8743}
8744
Glenn Kasten58123c32012-02-03 10:32:24 -08008745void AudioFlinger::EffectHandle::disconnect(bool unpinIfLast)
Marco Nelissen3a34bef2011-08-02 13:33:41 -07008746{
Glenn Kasten58123c32012-02-03 10:32:24 -08008747 ALOGV("disconnect(%s)", unpinIfLast ? "true" : "false");
Mathias Agopian65ab4712010-07-14 17:59:35 -07008748 if (mEffect == 0) {
8749 return;
8750 }
Glenn Kasten58123c32012-02-03 10:32:24 -08008751 mEffect->disconnect(this, unpinIfLast);
Eric Laurent59255e42011-07-27 19:49:51 -07008752
Eric Laurenta85a74a2011-10-19 11:44:54 -07008753 if (mHasControl && mEnabled) {
Eric Laurentdb7c0792011-08-10 10:37:50 -07008754 sp<ThreadBase> thread = mEffect->thread().promote();
8755 if (thread != 0) {
8756 thread->checkSuspendOnEffectEnabled(mEffect, false, mEffect->sessionId());
8757 }
Eric Laurent59255e42011-07-27 19:49:51 -07008758 }
8759
Mathias Agopian65ab4712010-07-14 17:59:35 -07008760 // release sp on module => module destructor can be called now
8761 mEffect.clear();
Mathias Agopian65ab4712010-07-14 17:59:35 -07008762 if (mClient != 0) {
Glenn Kastena0d68332012-01-27 16:47:15 -08008763 if (mCblk != NULL) {
Glenn Kasten1a0ae5b2012-02-03 10:24:48 -08008764 // unlike ~TrackBase(), mCblk is never a local new, so don't delete
Marco Nelissen3a34bef2011-08-02 13:33:41 -07008765 mCblk->~effect_param_cblk_t(); // destroy our shared-structure.
8766 }
Glenn Kastendbfafaf2012-01-25 15:27:15 -08008767 mCblkMemory.clear(); // free the shared memory before releasing the heap it belongs to
Glenn Kasten98ec94c2012-01-25 14:28:29 -08008768 // Client destructor must run with AudioFlinger mutex locked
Mathias Agopian65ab4712010-07-14 17:59:35 -07008769 Mutex::Autolock _l(mClient->audioFlinger()->mLock);
8770 mClient.clear();
8771 }
8772}
8773
Eric Laurent25f43952010-07-28 05:40:18 -07008774status_t AudioFlinger::EffectHandle::command(uint32_t cmdCode,
8775 uint32_t cmdSize,
8776 void *pCmdData,
8777 uint32_t *replySize,
8778 void *pReplyData)
Mathias Agopian65ab4712010-07-14 17:59:35 -07008779{
Steve Block3856b092011-10-20 11:56:00 +01008780// ALOGV("command(), cmdCode: %d, mHasControl: %d, mEffect: %p",
Eric Laurent25f43952010-07-28 05:40:18 -07008781// cmdCode, mHasControl, (mEffect == 0) ? 0 : mEffect.get());
Mathias Agopian65ab4712010-07-14 17:59:35 -07008782
8783 // only get parameter command is permitted for applications not controlling the effect
8784 if (!mHasControl && cmdCode != EFFECT_CMD_GET_PARAM) {
8785 return INVALID_OPERATION;
8786 }
8787 if (mEffect == 0) return DEAD_OBJECT;
Marco Nelissen3a34bef2011-08-02 13:33:41 -07008788 if (mClient == 0) return INVALID_OPERATION;
Mathias Agopian65ab4712010-07-14 17:59:35 -07008789
8790 // handle commands that are not forwarded transparently to effect engine
8791 if (cmdCode == EFFECT_CMD_SET_PARAM_COMMIT) {
8792 // No need to trylock() here as this function is executed in the binder thread serving a particular client process:
8793 // no risk to block the whole media server process or mixer threads is we are stuck here
8794 Mutex::Autolock _l(mCblk->lock);
8795 if (mCblk->clientIndex > EFFECT_PARAM_BUFFER_SIZE ||
8796 mCblk->serverIndex > EFFECT_PARAM_BUFFER_SIZE) {
8797 mCblk->serverIndex = 0;
8798 mCblk->clientIndex = 0;
8799 return BAD_VALUE;
8800 }
8801 status_t status = NO_ERROR;
8802 while (mCblk->serverIndex < mCblk->clientIndex) {
8803 int reply;
Eric Laurent25f43952010-07-28 05:40:18 -07008804 uint32_t rsize = sizeof(int);
Mathias Agopian65ab4712010-07-14 17:59:35 -07008805 int *p = (int *)(mBuffer + mCblk->serverIndex);
8806 int size = *p++;
8807 if (((uint8_t *)p + size) > mBuffer + mCblk->clientIndex) {
Steve Block5ff1dd52012-01-05 23:22:43 +00008808 ALOGW("command(): invalid parameter block size");
Mathias Agopian65ab4712010-07-14 17:59:35 -07008809 break;
8810 }
8811 effect_param_t *param = (effect_param_t *)p;
8812 if (param->psize == 0 || param->vsize == 0) {
Steve Block5ff1dd52012-01-05 23:22:43 +00008813 ALOGW("command(): null parameter or value size");
Mathias Agopian65ab4712010-07-14 17:59:35 -07008814 mCblk->serverIndex += size;
8815 continue;
8816 }
Eric Laurent25f43952010-07-28 05:40:18 -07008817 uint32_t psize = sizeof(effect_param_t) +
8818 ((param->psize - 1) / sizeof(int) + 1) * sizeof(int) +
8819 param->vsize;
8820 status_t ret = mEffect->command(EFFECT_CMD_SET_PARAM,
8821 psize,
8822 p,
8823 &rsize,
8824 &reply);
Eric Laurentaeae3de2010-09-02 11:56:55 -07008825 // stop at first error encountered
8826 if (ret != NO_ERROR) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07008827 status = ret;
Eric Laurentaeae3de2010-09-02 11:56:55 -07008828 *(int *)pReplyData = reply;
8829 break;
8830 } else if (reply != NO_ERROR) {
8831 *(int *)pReplyData = reply;
8832 break;
Mathias Agopian65ab4712010-07-14 17:59:35 -07008833 }
8834 mCblk->serverIndex += size;
8835 }
8836 mCblk->serverIndex = 0;
8837 mCblk->clientIndex = 0;
8838 return status;
8839 } else if (cmdCode == EFFECT_CMD_ENABLE) {
Eric Laurentaeae3de2010-09-02 11:56:55 -07008840 *(int *)pReplyData = NO_ERROR;
Mathias Agopian65ab4712010-07-14 17:59:35 -07008841 return enable();
8842 } else if (cmdCode == EFFECT_CMD_DISABLE) {
Eric Laurentaeae3de2010-09-02 11:56:55 -07008843 *(int *)pReplyData = NO_ERROR;
Mathias Agopian65ab4712010-07-14 17:59:35 -07008844 return disable();
8845 }
8846
8847 return mEffect->command(cmdCode, cmdSize, pCmdData, replySize, pReplyData);
8848}
8849
Eric Laurent59255e42011-07-27 19:49:51 -07008850void AudioFlinger::EffectHandle::setControl(bool hasControl, bool signal, bool enabled)
Mathias Agopian65ab4712010-07-14 17:59:35 -07008851{
Steve Block3856b092011-10-20 11:56:00 +01008852 ALOGV("setControl %p control %d", this, hasControl);
Mathias Agopian65ab4712010-07-14 17:59:35 -07008853
8854 mHasControl = hasControl;
Eric Laurent59255e42011-07-27 19:49:51 -07008855 mEnabled = enabled;
8856
Mathias Agopian65ab4712010-07-14 17:59:35 -07008857 if (signal && mEffectClient != 0) {
8858 mEffectClient->controlStatusChanged(hasControl);
8859 }
8860}
8861
Eric Laurent25f43952010-07-28 05:40:18 -07008862void AudioFlinger::EffectHandle::commandExecuted(uint32_t cmdCode,
8863 uint32_t cmdSize,
8864 void *pCmdData,
8865 uint32_t replySize,
8866 void *pReplyData)
Mathias Agopian65ab4712010-07-14 17:59:35 -07008867{
8868 if (mEffectClient != 0) {
8869 mEffectClient->commandExecuted(cmdCode, cmdSize, pCmdData, replySize, pReplyData);
8870 }
8871}
8872
8873
8874
8875void AudioFlinger::EffectHandle::setEnabled(bool enabled)
8876{
8877 if (mEffectClient != 0) {
8878 mEffectClient->enableStatusChanged(enabled);
8879 }
8880}
8881
8882status_t AudioFlinger::EffectHandle::onTransact(
8883 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
8884{
8885 return BnEffect::onTransact(code, data, reply, flags);
8886}
8887
8888
8889void AudioFlinger::EffectHandle::dump(char* buffer, size_t size)
8890{
Glenn Kastena0d68332012-01-27 16:47:15 -08008891 bool locked = mCblk != NULL && tryLock(mCblk->lock);
Mathias Agopian65ab4712010-07-14 17:59:35 -07008892
8893 snprintf(buffer, size, "\t\t\t%05d %05d %01u %01u %05u %05u\n",
Glenn Kasten44deb052012-02-05 18:09:08 -08008894 (mClient == 0) ? getpid_cached : mClient->pid(),
Mathias Agopian65ab4712010-07-14 17:59:35 -07008895 mPriority,
8896 mHasControl,
8897 !locked,
Marco Nelissen3a34bef2011-08-02 13:33:41 -07008898 mCblk ? mCblk->clientIndex : 0,
8899 mCblk ? mCblk->serverIndex : 0
Mathias Agopian65ab4712010-07-14 17:59:35 -07008900 );
8901
8902 if (locked) {
8903 mCblk->lock.unlock();
8904 }
8905}
8906
8907#undef LOG_TAG
8908#define LOG_TAG "AudioFlinger::EffectChain"
8909
Glenn Kasten9eaa5572012-01-20 13:32:16 -08008910AudioFlinger::EffectChain::EffectChain(ThreadBase *thread,
Mathias Agopian65ab4712010-07-14 17:59:35 -07008911 int sessionId)
Glenn Kasten9eaa5572012-01-20 13:32:16 -08008912 : mThread(thread), mSessionId(sessionId), mActiveTrackCnt(0), mTrackCnt(0), mTailBufferCount(0),
Eric Laurentb469b942011-05-09 12:09:06 -07008913 mOwnInBuffer(false), mVolumeCtrlIdx(-1), mLeftVolume(UINT_MAX), mRightVolume(UINT_MAX),
8914 mNewLeftVolume(UINT_MAX), mNewRightVolume(UINT_MAX)
Mathias Agopian65ab4712010-07-14 17:59:35 -07008915{
Dima Zavinfce7a472011-04-19 22:30:36 -07008916 mStrategy = AudioSystem::getStrategyForStream(AUDIO_STREAM_MUSIC);
Glenn Kasten9eaa5572012-01-20 13:32:16 -08008917 if (thread == NULL) {
Eric Laurent544fe9b2011-11-11 15:42:52 -08008918 return;
8919 }
8920 mMaxTailBuffers = ((kProcessTailDurationMs * thread->sampleRate()) / 1000) /
8921 thread->frameCount();
Mathias Agopian65ab4712010-07-14 17:59:35 -07008922}
8923
8924AudioFlinger::EffectChain::~EffectChain()
8925{
8926 if (mOwnInBuffer) {
8927 delete mInBuffer;
8928 }
8929
8930}
8931
Eric Laurent59255e42011-07-27 19:49:51 -07008932// getEffectFromDesc_l() must be called with ThreadBase::mLock held
Eric Laurentcab11242010-07-15 12:50:15 -07008933sp<AudioFlinger::EffectModule> AudioFlinger::EffectChain::getEffectFromDesc_l(effect_descriptor_t *descriptor)
Mathias Agopian65ab4712010-07-14 17:59:35 -07008934{
Mathias Agopian65ab4712010-07-14 17:59:35 -07008935 size_t size = mEffects.size();
8936
8937 for (size_t i = 0; i < size; i++) {
8938 if (memcmp(&mEffects[i]->desc().uuid, &descriptor->uuid, sizeof(effect_uuid_t)) == 0) {
Glenn Kasten090f0192012-01-30 13:00:02 -08008939 return mEffects[i];
Mathias Agopian65ab4712010-07-14 17:59:35 -07008940 }
8941 }
Glenn Kasten090f0192012-01-30 13:00:02 -08008942 return 0;
Mathias Agopian65ab4712010-07-14 17:59:35 -07008943}
8944
Eric Laurent59255e42011-07-27 19:49:51 -07008945// getEffectFromId_l() must be called with ThreadBase::mLock held
Eric Laurentcab11242010-07-15 12:50:15 -07008946sp<AudioFlinger::EffectModule> AudioFlinger::EffectChain::getEffectFromId_l(int id)
Mathias Agopian65ab4712010-07-14 17:59:35 -07008947{
Mathias Agopian65ab4712010-07-14 17:59:35 -07008948 size_t size = mEffects.size();
8949
8950 for (size_t i = 0; i < size; i++) {
Eric Laurentde070132010-07-13 04:45:46 -07008951 // by convention, return first effect if id provided is 0 (0 is never a valid id)
8952 if (id == 0 || mEffects[i]->id() == id) {
Glenn Kasten090f0192012-01-30 13:00:02 -08008953 return mEffects[i];
Mathias Agopian65ab4712010-07-14 17:59:35 -07008954 }
8955 }
Glenn Kasten090f0192012-01-30 13:00:02 -08008956 return 0;
Mathias Agopian65ab4712010-07-14 17:59:35 -07008957}
8958
Eric Laurent59255e42011-07-27 19:49:51 -07008959// getEffectFromType_l() must be called with ThreadBase::mLock held
8960sp<AudioFlinger::EffectModule> AudioFlinger::EffectChain::getEffectFromType_l(
8961 const effect_uuid_t *type)
8962{
Eric Laurent59255e42011-07-27 19:49:51 -07008963 size_t size = mEffects.size();
8964
8965 for (size_t i = 0; i < size; i++) {
8966 if (memcmp(&mEffects[i]->desc().type, type, sizeof(effect_uuid_t)) == 0) {
Glenn Kasten090f0192012-01-30 13:00:02 -08008967 return mEffects[i];
Eric Laurent59255e42011-07-27 19:49:51 -07008968 }
8969 }
Glenn Kasten090f0192012-01-30 13:00:02 -08008970 return 0;
Eric Laurent59255e42011-07-27 19:49:51 -07008971}
8972
Eric Laurent91b14c42012-05-30 12:30:29 -07008973void AudioFlinger::EffectChain::clearInputBuffer()
8974{
8975 Mutex::Autolock _l(mLock);
8976 sp<ThreadBase> thread = mThread.promote();
8977 if (thread == 0) {
8978 ALOGW("clearInputBuffer(): cannot promote mixer thread");
8979 return;
8980 }
8981 clearInputBuffer_l(thread);
8982}
8983
8984// Must be called with EffectChain::mLock locked
8985void AudioFlinger::EffectChain::clearInputBuffer_l(sp<ThreadBase> thread)
8986{
8987 size_t numSamples = thread->frameCount() * thread->channelCount();
8988 memset(mInBuffer, 0, numSamples * sizeof(int16_t));
8989
8990}
8991
Mathias Agopian65ab4712010-07-14 17:59:35 -07008992// Must be called with EffectChain::mLock locked
8993void AudioFlinger::EffectChain::process_l()
8994{
Eric Laurentdac69112010-09-28 14:09:57 -07008995 sp<ThreadBase> thread = mThread.promote();
8996 if (thread == 0) {
Steve Block5ff1dd52012-01-05 23:22:43 +00008997 ALOGW("process_l(): cannot promote mixer thread");
Eric Laurentdac69112010-09-28 14:09:57 -07008998 return;
8999 }
Dima Zavinfce7a472011-04-19 22:30:36 -07009000 bool isGlobalSession = (mSessionId == AUDIO_SESSION_OUTPUT_MIX) ||
9001 (mSessionId == AUDIO_SESSION_OUTPUT_STAGE);
Eric Laurent544fe9b2011-11-11 15:42:52 -08009002 // always process effects unless no more tracks are on the session and the effect tail
9003 // has been rendered
9004 bool doProcess = true;
Eric Laurentdac69112010-09-28 14:09:57 -07009005 if (!isGlobalSession) {
Eric Laurent544fe9b2011-11-11 15:42:52 -08009006 bool tracksOnSession = (trackCnt() != 0);
Eric Laurentb469b942011-05-09 12:09:06 -07009007
Eric Laurent544fe9b2011-11-11 15:42:52 -08009008 if (!tracksOnSession && mTailBufferCount == 0) {
9009 doProcess = false;
9010 }
9011
9012 if (activeTrackCnt() == 0) {
9013 // if no track is active and the effect tail has not been rendered,
9014 // the input buffer must be cleared here as the mixer process will not do it
9015 if (tracksOnSession || mTailBufferCount > 0) {
Eric Laurent91b14c42012-05-30 12:30:29 -07009016 clearInputBuffer_l(thread);
Eric Laurent544fe9b2011-11-11 15:42:52 -08009017 if (mTailBufferCount > 0) {
9018 mTailBufferCount--;
9019 }
9020 }
9021 }
Eric Laurentdac69112010-09-28 14:09:57 -07009022 }
9023
Mathias Agopian65ab4712010-07-14 17:59:35 -07009024 size_t size = mEffects.size();
Eric Laurent544fe9b2011-11-11 15:42:52 -08009025 if (doProcess) {
Eric Laurentdac69112010-09-28 14:09:57 -07009026 for (size_t i = 0; i < size; i++) {
9027 mEffects[i]->process();
9028 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07009029 }
9030 for (size_t i = 0; i < size; i++) {
9031 mEffects[i]->updateState();
9032 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07009033}
9034
Eric Laurentcab11242010-07-15 12:50:15 -07009035// addEffect_l() must be called with PlaybackThread::mLock held
Eric Laurentde070132010-07-13 04:45:46 -07009036status_t AudioFlinger::EffectChain::addEffect_l(const sp<EffectModule>& effect)
Mathias Agopian65ab4712010-07-14 17:59:35 -07009037{
9038 effect_descriptor_t desc = effect->desc();
9039 uint32_t insertPref = desc.flags & EFFECT_FLAG_INSERT_MASK;
9040
9041 Mutex::Autolock _l(mLock);
Eric Laurentde070132010-07-13 04:45:46 -07009042 effect->setChain(this);
9043 sp<ThreadBase> thread = mThread.promote();
9044 if (thread == 0) {
9045 return NO_INIT;
9046 }
9047 effect->setThread(thread);
Mathias Agopian65ab4712010-07-14 17:59:35 -07009048
9049 if ((desc.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
9050 // Auxiliary effects are inserted at the beginning of mEffects vector as
9051 // they are processed first and accumulated in chain input buffer
9052 mEffects.insertAt(effect, 0);
Eric Laurentde070132010-07-13 04:45:46 -07009053
Mathias Agopian65ab4712010-07-14 17:59:35 -07009054 // the input buffer for auxiliary effect contains mono samples in
9055 // 32 bit format. This is to avoid saturation in AudoMixer
9056 // accumulation stage. Saturation is done in EffectModule::process() before
9057 // calling the process in effect engine
9058 size_t numSamples = thread->frameCount();
9059 int32_t *buffer = new int32_t[numSamples];
9060 memset(buffer, 0, numSamples * sizeof(int32_t));
9061 effect->setInBuffer((int16_t *)buffer);
9062 // auxiliary effects output samples to chain input buffer for further processing
9063 // by insert effects
9064 effect->setOutBuffer(mInBuffer);
9065 } else {
9066 // Insert effects are inserted at the end of mEffects vector as they are processed
9067 // after track and auxiliary effects.
9068 // Insert effect order as a function of indicated preference:
9069 // if EFFECT_FLAG_INSERT_EXCLUSIVE, insert in first position or reject if
9070 // another effect is present
9071 // else if EFFECT_FLAG_INSERT_FIRST, insert in first position or after the
9072 // last effect claiming first position
9073 // else if EFFECT_FLAG_INSERT_LAST, insert in last position or before the
9074 // first effect claiming last position
9075 // else if EFFECT_FLAG_INSERT_ANY insert after first or before last
9076 // Reject insertion if an effect with EFFECT_FLAG_INSERT_EXCLUSIVE is
9077 // already present
9078
Glenn Kasten8d6a2442012-02-08 14:04:28 -08009079 size_t size = mEffects.size();
9080 size_t idx_insert = size;
9081 ssize_t idx_insert_first = -1;
9082 ssize_t idx_insert_last = -1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07009083
Glenn Kasten8d6a2442012-02-08 14:04:28 -08009084 for (size_t i = 0; i < size; i++) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07009085 effect_descriptor_t d = mEffects[i]->desc();
9086 uint32_t iMode = d.flags & EFFECT_FLAG_TYPE_MASK;
9087 uint32_t iPref = d.flags & EFFECT_FLAG_INSERT_MASK;
9088 if (iMode == EFFECT_FLAG_TYPE_INSERT) {
9089 // check invalid effect chaining combinations
9090 if (insertPref == EFFECT_FLAG_INSERT_EXCLUSIVE ||
9091 iPref == EFFECT_FLAG_INSERT_EXCLUSIVE) {
Steve Block5ff1dd52012-01-05 23:22:43 +00009092 ALOGW("addEffect_l() could not insert effect %s: exclusive conflict with %s", desc.name, d.name);
Mathias Agopian65ab4712010-07-14 17:59:35 -07009093 return INVALID_OPERATION;
9094 }
9095 // remember position of first insert effect and by default
9096 // select this as insert position for new effect
9097 if (idx_insert == size) {
9098 idx_insert = i;
9099 }
9100 // remember position of last insert effect claiming
9101 // first position
9102 if (iPref == EFFECT_FLAG_INSERT_FIRST) {
9103 idx_insert_first = i;
9104 }
9105 // remember position of first insert effect claiming
9106 // last position
9107 if (iPref == EFFECT_FLAG_INSERT_LAST &&
9108 idx_insert_last == -1) {
9109 idx_insert_last = i;
9110 }
9111 }
9112 }
9113
9114 // modify idx_insert from first position if needed
9115 if (insertPref == EFFECT_FLAG_INSERT_LAST) {
9116 if (idx_insert_last != -1) {
9117 idx_insert = idx_insert_last;
9118 } else {
9119 idx_insert = size;
9120 }
9121 } else {
9122 if (idx_insert_first != -1) {
9123 idx_insert = idx_insert_first + 1;
9124 }
9125 }
9126
9127 // always read samples from chain input buffer
9128 effect->setInBuffer(mInBuffer);
9129
9130 // if last effect in the chain, output samples to chain
9131 // output buffer, otherwise to chain input buffer
9132 if (idx_insert == size) {
9133 if (idx_insert != 0) {
9134 mEffects[idx_insert-1]->setOutBuffer(mInBuffer);
9135 mEffects[idx_insert-1]->configure();
9136 }
9137 effect->setOutBuffer(mOutBuffer);
9138 } else {
9139 effect->setOutBuffer(mInBuffer);
9140 }
9141 mEffects.insertAt(effect, idx_insert);
Mathias Agopian65ab4712010-07-14 17:59:35 -07009142
Steve Block3856b092011-10-20 11:56:00 +01009143 ALOGV("addEffect_l() effect %p, added in chain %p at rank %d", effect.get(), this, idx_insert);
Mathias Agopian65ab4712010-07-14 17:59:35 -07009144 }
9145 effect->configure();
9146 return NO_ERROR;
9147}
9148
Eric Laurentcab11242010-07-15 12:50:15 -07009149// removeEffect_l() must be called with PlaybackThread::mLock held
9150size_t AudioFlinger::EffectChain::removeEffect_l(const sp<EffectModule>& effect)
Mathias Agopian65ab4712010-07-14 17:59:35 -07009151{
9152 Mutex::Autolock _l(mLock);
Glenn Kasten8d6a2442012-02-08 14:04:28 -08009153 size_t size = mEffects.size();
Mathias Agopian65ab4712010-07-14 17:59:35 -07009154 uint32_t type = effect->desc().flags & EFFECT_FLAG_TYPE_MASK;
9155
Glenn Kasten8d6a2442012-02-08 14:04:28 -08009156 for (size_t i = 0; i < size; i++) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07009157 if (effect == mEffects[i]) {
Eric Laurentec437d82011-07-26 20:54:46 -07009158 // calling stop here will remove pre-processing effect from the audio HAL.
9159 // This is safe as we hold the EffectChain mutex which guarantees that we are not in
9160 // the middle of a read from audio HAL
Eric Laurentec35a142011-10-05 17:42:25 -07009161 if (mEffects[i]->state() == EffectModule::ACTIVE ||
9162 mEffects[i]->state() == EffectModule::STOPPING) {
9163 mEffects[i]->stop();
9164 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07009165 if (type == EFFECT_FLAG_TYPE_AUXILIARY) {
9166 delete[] effect->inBuffer();
9167 } else {
9168 if (i == size - 1 && i != 0) {
9169 mEffects[i - 1]->setOutBuffer(mOutBuffer);
9170 mEffects[i - 1]->configure();
9171 }
9172 }
9173 mEffects.removeAt(i);
Steve Block3856b092011-10-20 11:56:00 +01009174 ALOGV("removeEffect_l() effect %p, removed from chain %p at rank %d", effect.get(), this, i);
Mathias Agopian65ab4712010-07-14 17:59:35 -07009175 break;
9176 }
9177 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07009178
9179 return mEffects.size();
9180}
9181
Eric Laurentcab11242010-07-15 12:50:15 -07009182// setDevice_l() must be called with PlaybackThread::mLock held
9183void AudioFlinger::EffectChain::setDevice_l(uint32_t device)
Mathias Agopian65ab4712010-07-14 17:59:35 -07009184{
9185 size_t size = mEffects.size();
9186 for (size_t i = 0; i < size; i++) {
9187 mEffects[i]->setDevice(device);
9188 }
9189}
9190
Eric Laurentcab11242010-07-15 12:50:15 -07009191// setMode_l() must be called with PlaybackThread::mLock held
Glenn Kastenf78aee72012-01-04 11:00:47 -08009192void AudioFlinger::EffectChain::setMode_l(audio_mode_t mode)
Mathias Agopian65ab4712010-07-14 17:59:35 -07009193{
9194 size_t size = mEffects.size();
9195 for (size_t i = 0; i < size; i++) {
9196 mEffects[i]->setMode(mode);
9197 }
9198}
9199
Eric Laurentcab11242010-07-15 12:50:15 -07009200// setVolume_l() must be called with PlaybackThread::mLock held
9201bool AudioFlinger::EffectChain::setVolume_l(uint32_t *left, uint32_t *right)
Mathias Agopian65ab4712010-07-14 17:59:35 -07009202{
9203 uint32_t newLeft = *left;
9204 uint32_t newRight = *right;
9205 bool hasControl = false;
Eric Laurentcab11242010-07-15 12:50:15 -07009206 int ctrlIdx = -1;
9207 size_t size = mEffects.size();
Mathias Agopian65ab4712010-07-14 17:59:35 -07009208
Eric Laurentcab11242010-07-15 12:50:15 -07009209 // first update volume controller
9210 for (size_t i = size; i > 0; i--) {
Eric Laurent8f45bd72010-08-31 13:50:07 -07009211 if (mEffects[i - 1]->isProcessEnabled() &&
Eric Laurentcab11242010-07-15 12:50:15 -07009212 (mEffects[i - 1]->desc().flags & EFFECT_FLAG_VOLUME_MASK) == EFFECT_FLAG_VOLUME_CTRL) {
9213 ctrlIdx = i - 1;
Eric Laurentf997cab2010-07-19 06:24:46 -07009214 hasControl = true;
Eric Laurentcab11242010-07-15 12:50:15 -07009215 break;
9216 }
9217 }
9218
9219 if (ctrlIdx == mVolumeCtrlIdx && *left == mLeftVolume && *right == mRightVolume) {
Eric Laurentf997cab2010-07-19 06:24:46 -07009220 if (hasControl) {
9221 *left = mNewLeftVolume;
9222 *right = mNewRightVolume;
9223 }
9224 return hasControl;
Eric Laurentcab11242010-07-15 12:50:15 -07009225 }
9226
9227 mVolumeCtrlIdx = ctrlIdx;
Eric Laurentf997cab2010-07-19 06:24:46 -07009228 mLeftVolume = newLeft;
9229 mRightVolume = newRight;
Eric Laurentcab11242010-07-15 12:50:15 -07009230
9231 // second get volume update from volume controller
9232 if (ctrlIdx >= 0) {
9233 mEffects[ctrlIdx]->setVolume(&newLeft, &newRight, true);
Eric Laurentf997cab2010-07-19 06:24:46 -07009234 mNewLeftVolume = newLeft;
9235 mNewRightVolume = newRight;
Mathias Agopian65ab4712010-07-14 17:59:35 -07009236 }
9237 // then indicate volume to all other effects in chain.
9238 // Pass altered volume to effects before volume controller
9239 // and requested volume to effects after controller
9240 uint32_t lVol = newLeft;
9241 uint32_t rVol = newRight;
Eric Laurentcab11242010-07-15 12:50:15 -07009242
Mathias Agopian65ab4712010-07-14 17:59:35 -07009243 for (size_t i = 0; i < size; i++) {
Eric Laurentcab11242010-07-15 12:50:15 -07009244 if ((int)i == ctrlIdx) continue;
9245 // this also works for ctrlIdx == -1 when there is no volume controller
9246 if ((int)i > ctrlIdx) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07009247 lVol = *left;
9248 rVol = *right;
9249 }
9250 mEffects[i]->setVolume(&lVol, &rVol, false);
9251 }
9252 *left = newLeft;
9253 *right = newRight;
9254
9255 return hasControl;
9256}
9257
Mathias Agopian65ab4712010-07-14 17:59:35 -07009258status_t AudioFlinger::EffectChain::dump(int fd, const Vector<String16>& args)
9259{
9260 const size_t SIZE = 256;
9261 char buffer[SIZE];
9262 String8 result;
9263
9264 snprintf(buffer, SIZE, "Effects for session %d:\n", mSessionId);
9265 result.append(buffer);
9266
9267 bool locked = tryLock(mLock);
9268 // failed to lock - AudioFlinger is probably deadlocked
9269 if (!locked) {
9270 result.append("\tCould not lock mutex:\n");
9271 }
9272
Eric Laurentcab11242010-07-15 12:50:15 -07009273 result.append("\tNum fx In buffer Out buffer Active tracks:\n");
9274 snprintf(buffer, SIZE, "\t%02d 0x%08x 0x%08x %d\n",
Mathias Agopian65ab4712010-07-14 17:59:35 -07009275 mEffects.size(),
9276 (uint32_t)mInBuffer,
9277 (uint32_t)mOutBuffer,
Mathias Agopian65ab4712010-07-14 17:59:35 -07009278 mActiveTrackCnt);
9279 result.append(buffer);
9280 write(fd, result.string(), result.size());
9281
9282 for (size_t i = 0; i < mEffects.size(); ++i) {
9283 sp<EffectModule> effect = mEffects[i];
9284 if (effect != 0) {
9285 effect->dump(fd, args);
9286 }
9287 }
9288
9289 if (locked) {
9290 mLock.unlock();
9291 }
9292
9293 return NO_ERROR;
9294}
9295
Eric Laurent59255e42011-07-27 19:49:51 -07009296// must be called with ThreadBase::mLock held
9297void AudioFlinger::EffectChain::setEffectSuspended_l(
9298 const effect_uuid_t *type, bool suspend)
9299{
9300 sp<SuspendedEffectDesc> desc;
9301 // use effect type UUID timelow as key as there is no real risk of identical
9302 // timeLow fields among effect type UUIDs.
Glenn Kasten8d6a2442012-02-08 14:04:28 -08009303 ssize_t index = mSuspendedEffects.indexOfKey(type->timeLow);
Eric Laurent59255e42011-07-27 19:49:51 -07009304 if (suspend) {
9305 if (index >= 0) {
9306 desc = mSuspendedEffects.valueAt(index);
9307 } else {
9308 desc = new SuspendedEffectDesc();
9309 memcpy(&desc->mType, type, sizeof(effect_uuid_t));
9310 mSuspendedEffects.add(type->timeLow, desc);
Steve Block3856b092011-10-20 11:56:00 +01009311 ALOGV("setEffectSuspended_l() add entry for %08x", type->timeLow);
Eric Laurent59255e42011-07-27 19:49:51 -07009312 }
9313 if (desc->mRefCount++ == 0) {
9314 sp<EffectModule> effect = getEffectIfEnabled(type);
9315 if (effect != 0) {
9316 desc->mEffect = effect;
9317 effect->setSuspended(true);
9318 effect->setEnabled(false);
9319 }
9320 }
9321 } else {
9322 if (index < 0) {
9323 return;
9324 }
9325 desc = mSuspendedEffects.valueAt(index);
9326 if (desc->mRefCount <= 0) {
Steve Block5ff1dd52012-01-05 23:22:43 +00009327 ALOGW("setEffectSuspended_l() restore refcount should not be 0 %d", desc->mRefCount);
Eric Laurent59255e42011-07-27 19:49:51 -07009328 desc->mRefCount = 1;
9329 }
9330 if (--desc->mRefCount == 0) {
Steve Block3856b092011-10-20 11:56:00 +01009331 ALOGV("setEffectSuspended_l() remove entry for %08x", mSuspendedEffects.keyAt(index));
Eric Laurent59255e42011-07-27 19:49:51 -07009332 if (desc->mEffect != 0) {
9333 sp<EffectModule> effect = desc->mEffect.promote();
9334 if (effect != 0) {
9335 effect->setSuspended(false);
9336 sp<EffectHandle> handle = effect->controlHandle();
9337 if (handle != 0) {
9338 effect->setEnabled(handle->enabled());
9339 }
9340 }
9341 desc->mEffect.clear();
9342 }
9343 mSuspendedEffects.removeItemsAt(index);
9344 }
9345 }
9346}
9347
9348// must be called with ThreadBase::mLock held
9349void AudioFlinger::EffectChain::setEffectSuspendedAll_l(bool suspend)
9350{
9351 sp<SuspendedEffectDesc> desc;
9352
Glenn Kasten8d6a2442012-02-08 14:04:28 -08009353 ssize_t index = mSuspendedEffects.indexOfKey((int)kKeyForSuspendAll);
Eric Laurent59255e42011-07-27 19:49:51 -07009354 if (suspend) {
9355 if (index >= 0) {
9356 desc = mSuspendedEffects.valueAt(index);
9357 } else {
9358 desc = new SuspendedEffectDesc();
9359 mSuspendedEffects.add((int)kKeyForSuspendAll, desc);
Steve Block3856b092011-10-20 11:56:00 +01009360 ALOGV("setEffectSuspendedAll_l() add entry for 0");
Eric Laurent59255e42011-07-27 19:49:51 -07009361 }
9362 if (desc->mRefCount++ == 0) {
Glenn Kastend0539712012-01-30 12:56:03 -08009363 Vector< sp<EffectModule> > effects;
9364 getSuspendEligibleEffects(effects);
Eric Laurent59255e42011-07-27 19:49:51 -07009365 for (size_t i = 0; i < effects.size(); i++) {
9366 setEffectSuspended_l(&effects[i]->desc().type, true);
9367 }
9368 }
9369 } else {
9370 if (index < 0) {
9371 return;
9372 }
9373 desc = mSuspendedEffects.valueAt(index);
9374 if (desc->mRefCount <= 0) {
Steve Block5ff1dd52012-01-05 23:22:43 +00009375 ALOGW("setEffectSuspendedAll_l() restore refcount should not be 0 %d", desc->mRefCount);
Eric Laurent59255e42011-07-27 19:49:51 -07009376 desc->mRefCount = 1;
9377 }
9378 if (--desc->mRefCount == 0) {
9379 Vector<const effect_uuid_t *> types;
9380 for (size_t i = 0; i < mSuspendedEffects.size(); i++) {
9381 if (mSuspendedEffects.keyAt(i) == (int)kKeyForSuspendAll) {
9382 continue;
9383 }
9384 types.add(&mSuspendedEffects.valueAt(i)->mType);
9385 }
9386 for (size_t i = 0; i < types.size(); i++) {
9387 setEffectSuspended_l(types[i], false);
9388 }
Steve Block3856b092011-10-20 11:56:00 +01009389 ALOGV("setEffectSuspendedAll_l() remove entry for %08x", mSuspendedEffects.keyAt(index));
Eric Laurent59255e42011-07-27 19:49:51 -07009390 mSuspendedEffects.removeItem((int)kKeyForSuspendAll);
9391 }
9392 }
9393}
9394
Eric Laurent6bffdb82011-09-23 08:40:41 -07009395
9396// The volume effect is used for automated tests only
9397#ifndef OPENSL_ES_H_
9398static const effect_uuid_t SL_IID_VOLUME_ = { 0x09e8ede0, 0xddde, 0x11db, 0xb4f6,
9399 { 0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b } };
9400const effect_uuid_t * const SL_IID_VOLUME = &SL_IID_VOLUME_;
9401#endif //OPENSL_ES_H_
9402
Eric Laurentdb7c0792011-08-10 10:37:50 -07009403bool AudioFlinger::EffectChain::isEffectEligibleForSuspend(const effect_descriptor_t& desc)
9404{
9405 // auxiliary effects and visualizer are never suspended on output mix
9406 if ((mSessionId == AUDIO_SESSION_OUTPUT_MIX) &&
9407 (((desc.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) ||
Eric Laurent6bffdb82011-09-23 08:40:41 -07009408 (memcmp(&desc.type, SL_IID_VISUALIZATION, sizeof(effect_uuid_t)) == 0) ||
9409 (memcmp(&desc.type, SL_IID_VOLUME, sizeof(effect_uuid_t)) == 0))) {
Eric Laurentdb7c0792011-08-10 10:37:50 -07009410 return false;
9411 }
9412 return true;
9413}
9414
Glenn Kastend0539712012-01-30 12:56:03 -08009415void AudioFlinger::EffectChain::getSuspendEligibleEffects(Vector< sp<AudioFlinger::EffectModule> > &effects)
Eric Laurent59255e42011-07-27 19:49:51 -07009416{
Glenn Kastend0539712012-01-30 12:56:03 -08009417 effects.clear();
Eric Laurent59255e42011-07-27 19:49:51 -07009418 for (size_t i = 0; i < mEffects.size(); i++) {
Glenn Kastend0539712012-01-30 12:56:03 -08009419 if (isEffectEligibleForSuspend(mEffects[i]->desc())) {
9420 effects.add(mEffects[i]);
Eric Laurent59255e42011-07-27 19:49:51 -07009421 }
Eric Laurent59255e42011-07-27 19:49:51 -07009422 }
Eric Laurent59255e42011-07-27 19:49:51 -07009423}
9424
9425sp<AudioFlinger::EffectModule> AudioFlinger::EffectChain::getEffectIfEnabled(
9426 const effect_uuid_t *type)
9427{
Glenn Kasten090f0192012-01-30 13:00:02 -08009428 sp<EffectModule> effect = getEffectFromType_l(type);
9429 return effect != 0 && effect->isEnabled() ? effect : 0;
Eric Laurent59255e42011-07-27 19:49:51 -07009430}
9431
9432void AudioFlinger::EffectChain::checkSuspendOnEffectEnabled(const sp<EffectModule>& effect,
9433 bool enabled)
9434{
Glenn Kasten8d6a2442012-02-08 14:04:28 -08009435 ssize_t index = mSuspendedEffects.indexOfKey(effect->desc().type.timeLow);
Eric Laurent59255e42011-07-27 19:49:51 -07009436 if (enabled) {
9437 if (index < 0) {
9438 // if the effect is not suspend check if all effects are suspended
9439 index = mSuspendedEffects.indexOfKey((int)kKeyForSuspendAll);
9440 if (index < 0) {
9441 return;
9442 }
Eric Laurentdb7c0792011-08-10 10:37:50 -07009443 if (!isEffectEligibleForSuspend(effect->desc())) {
9444 return;
9445 }
Eric Laurent59255e42011-07-27 19:49:51 -07009446 setEffectSuspended_l(&effect->desc().type, enabled);
9447 index = mSuspendedEffects.indexOfKey(effect->desc().type.timeLow);
Eric Laurentdb7c0792011-08-10 10:37:50 -07009448 if (index < 0) {
Steve Block5ff1dd52012-01-05 23:22:43 +00009449 ALOGW("checkSuspendOnEffectEnabled() Fx should be suspended here!");
Eric Laurentdb7c0792011-08-10 10:37:50 -07009450 return;
9451 }
Eric Laurent59255e42011-07-27 19:49:51 -07009452 }
Steve Block3856b092011-10-20 11:56:00 +01009453 ALOGV("checkSuspendOnEffectEnabled() enable suspending fx %08x",
Glenn Kastene53b9ea2012-03-12 16:29:55 -07009454 effect->desc().type.timeLow);
Eric Laurent59255e42011-07-27 19:49:51 -07009455 sp<SuspendedEffectDesc> desc = mSuspendedEffects.valueAt(index);
9456 // if effect is requested to suspended but was not yet enabled, supend it now.
9457 if (desc->mEffect == 0) {
9458 desc->mEffect = effect;
9459 effect->setEnabled(false);
9460 effect->setSuspended(true);
9461 }
9462 } else {
9463 if (index < 0) {
9464 return;
9465 }
Steve Block3856b092011-10-20 11:56:00 +01009466 ALOGV("checkSuspendOnEffectEnabled() disable restoring fx %08x",
Glenn Kastene53b9ea2012-03-12 16:29:55 -07009467 effect->desc().type.timeLow);
Eric Laurent59255e42011-07-27 19:49:51 -07009468 sp<SuspendedEffectDesc> desc = mSuspendedEffects.valueAt(index);
9469 desc->mEffect.clear();
9470 effect->setSuspended(false);
9471 }
9472}
9473
Mathias Agopian65ab4712010-07-14 17:59:35 -07009474#undef LOG_TAG
9475#define LOG_TAG "AudioFlinger"
9476
9477// ----------------------------------------------------------------------------
9478
9479status_t AudioFlinger::onTransact(
9480 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
9481{
9482 return BnAudioFlinger::onTransact(code, data, reply, flags);
9483}
9484
Mathias Agopian65ab4712010-07-14 17:59:35 -07009485}; // namespace android