blob: a4ed445943dafd305881c4d270f4fc913b6aca43 [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#define LOG_TAG "AudioMixer"
19//#define LOG_NDEBUG 0
20
21#include <stdint.h>
22#include <string.h>
23#include <stdlib.h>
24#include <sys/types.h>
25
26#include <utils/Errors.h>
27#include <utils/Log.h>
28
Jean-Michel Trivi0d255b22011-05-24 15:53:33 -070029#include <cutils/bitops.h>
Glenn Kastenf6b16782011-12-15 09:51:17 -080030#include <cutils/compiler.h>
Glenn Kasten5798d4e2012-03-08 12:18:35 -080031#include <utils/Debug.h>
Jean-Michel Trivi0d255b22011-05-24 15:53:33 -070032
33#include <system/audio.h>
34
Glenn Kasten3b21c502011-12-15 09:52:39 -080035#include <audio_utils/primitives.h>
John Grossman4ff14ba2012-02-08 16:37:41 -080036#include <common_time/local_clock.h>
37#include <common_time/cc_helper.h>
Glenn Kasten3b21c502011-12-15 09:52:39 -080038
Jean-Michel Trivi7d5b2622012-04-04 18:54:36 -070039#include <media/EffectsFactoryApi.h>
40
Mathias Agopian65ab4712010-07-14 17:59:35 -070041#include "AudioMixer.h"
42
43namespace android {
Mathias Agopian65ab4712010-07-14 17:59:35 -070044
45// ----------------------------------------------------------------------------
Jean-Michel Trivi7d5b2622012-04-04 18:54:36 -070046AudioMixer::DownmixerBufferProvider::DownmixerBufferProvider() : AudioBufferProvider(),
47 mTrackBufferProvider(NULL), mDownmixHandle(NULL)
48{
49}
50
51AudioMixer::DownmixerBufferProvider::~DownmixerBufferProvider()
52{
53 ALOGV("AudioMixer deleting DownmixerBufferProvider (%p)", this);
54 EffectRelease(mDownmixHandle);
55}
56
57status_t AudioMixer::DownmixerBufferProvider::getNextBuffer(AudioBufferProvider::Buffer *pBuffer,
58 int64_t pts) {
59 //ALOGV("DownmixerBufferProvider::getNextBuffer()");
60 if (this->mTrackBufferProvider != NULL) {
61 status_t res = mTrackBufferProvider->getNextBuffer(pBuffer, pts);
62 if (res == OK) {
63 mDownmixConfig.inputCfg.buffer.frameCount = pBuffer->frameCount;
64 mDownmixConfig.inputCfg.buffer.raw = pBuffer->raw;
65 mDownmixConfig.outputCfg.buffer.frameCount = pBuffer->frameCount;
66 mDownmixConfig.outputCfg.buffer.raw = mDownmixConfig.inputCfg.buffer.raw;
67 // in-place so overwrite the buffer contents, has been set in prepareTrackForDownmix()
68 //mDownmixConfig.outputCfg.accessMode = EFFECT_BUFFER_ACCESS_WRITE;
69
70 res = (*mDownmixHandle)->process(mDownmixHandle,
71 &mDownmixConfig.inputCfg.buffer, &mDownmixConfig.outputCfg.buffer);
Jean-Michel Trivi9bd23222012-04-16 13:43:48 -070072 //ALOGV("getNextBuffer is downmixing");
Jean-Michel Trivi7d5b2622012-04-04 18:54:36 -070073 }
74 return res;
75 } else {
76 ALOGE("DownmixerBufferProvider::getNextBuffer() error: NULL track buffer provider");
77 return NO_INIT;
78 }
79}
80
81void AudioMixer::DownmixerBufferProvider::releaseBuffer(AudioBufferProvider::Buffer *pBuffer) {
Jean-Michel Trivi9bd23222012-04-16 13:43:48 -070082 //ALOGV("DownmixerBufferProvider::releaseBuffer()");
Jean-Michel Trivi7d5b2622012-04-04 18:54:36 -070083 if (this->mTrackBufferProvider != NULL) {
84 mTrackBufferProvider->releaseBuffer(pBuffer);
85 } else {
86 ALOGE("DownmixerBufferProvider::releaseBuffer() error: NULL track buffer provider");
87 }
88}
89
90
91// ----------------------------------------------------------------------------
92bool AudioMixer::isMultichannelCapable = false;
93
94effect_descriptor_t AudioMixer::dwnmFxDesc;
Mathias Agopian65ab4712010-07-14 17:59:35 -070095
Paul Lind3c0a0e82012-08-01 18:49:49 -070096// Ensure mConfiguredNames bitmask is initialized properly on all architectures.
97// The value of 1 << x is undefined in C when x >= 32.
98
Glenn Kasten5c94b6c2012-03-20 17:01:29 -070099AudioMixer::AudioMixer(size_t frameCount, uint32_t sampleRate, uint32_t maxNumTracks)
Paul Lind3c0a0e82012-08-01 18:49:49 -0700100 : mTrackNames(0), mConfiguredNames((maxNumTracks >= 32 ? 0 : 1 << maxNumTracks) - 1),
101 mSampleRate(sampleRate)
Mathias Agopian65ab4712010-07-14 17:59:35 -0700102{
Glenn Kasten788040c2011-05-05 08:19:00 -0700103 // AudioMixer is not yet capable of multi-channel beyond stereo
Glenn Kasten5798d4e2012-03-08 12:18:35 -0800104 COMPILE_TIME_ASSERT_FUNCTION_SCOPE(2 == MAX_NUM_CHANNELS);
Jean-Michel Triviacb86cc2012-04-16 12:43:57 -0700105
Glenn Kasten5c94b6c2012-03-20 17:01:29 -0700106 ALOG_ASSERT(maxNumTracks <= MAX_NUM_TRACKS, "maxNumTracks %u > MAX_NUM_TRACKS %u",
107 maxNumTracks, MAX_NUM_TRACKS);
108
Glenn Kastend82c7502012-03-08 12:33:37 -0800109 // AudioMixer is not yet capable of more than 32 active track inputs
110 ALOG_ASSERT(32 >= MAX_NUM_TRACKS, "bad MAX_NUM_TRACKS %d", MAX_NUM_TRACKS);
111
112 // AudioMixer is not yet capable of multi-channel output beyond stereo
113 ALOG_ASSERT(2 == MAX_NUM_CHANNELS, "bad MAX_NUM_CHANNELS %d", MAX_NUM_CHANNELS);
114
John Grossman4ff14ba2012-02-08 16:37:41 -0800115 LocalClock lc;
116
Glenn Kasten52008f82012-03-18 09:34:41 -0700117 pthread_once(&sOnceControl, &sInitRoutine);
118
Mathias Agopian65ab4712010-07-14 17:59:35 -0700119 mState.enabledTracks= 0;
120 mState.needsChanged = 0;
121 mState.frameCount = frameCount;
Glenn Kasten84afa3b2012-01-25 15:28:08 -0800122 mState.hook = process__nop;
Glenn Kastene0feee32011-12-13 11:53:26 -0800123 mState.outputTemp = NULL;
124 mState.resampleTemp = NULL;
Glenn Kasten84afa3b2012-01-25 15:28:08 -0800125 // mState.reserved
Glenn Kasten17a736c2012-02-14 08:52:15 -0800126
127 // FIXME Most of the following initialization is probably redundant since
128 // tracks[i] should only be referenced if (mTrackNames & (1 << i)) != 0
129 // and mTrackNames is initially 0. However, leave it here until that's verified.
Mathias Agopian65ab4712010-07-14 17:59:35 -0700130 track_t* t = mState.tracks;
Glenn Kastenbf71f1e2011-12-13 11:52:35 -0800131 for (unsigned i=0 ; i < MAX_NUM_TRACKS ; i++) {
Eric Laurenta5e82142012-04-16 13:47:17 -0700132 t->resampler = NULL;
Jean-Michel Trivi9bd23222012-04-16 13:43:48 -0700133 t->downmixerBufferProvider = NULL;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700134 t++;
135 }
Jean-Michel Trivi7d5b2622012-04-04 18:54:36 -0700136
137 // find multichannel downmix effect if we have to play multichannel content
138 uint32_t numEffects = 0;
139 int ret = EffectQueryNumberEffects(&numEffects);
140 if (ret != 0) {
141 ALOGE("AudioMixer() error %d querying number of effects", ret);
142 return;
143 }
144 ALOGV("EffectQueryNumberEffects() numEffects=%d", numEffects);
145
146 for (uint32_t i = 0 ; i < numEffects ; i++) {
147 if (EffectQueryEffect(i, &dwnmFxDesc) == 0) {
148 ALOGV("effect %d is called %s", i, dwnmFxDesc.name);
149 if (memcmp(&dwnmFxDesc.type, EFFECT_UIID_DOWNMIX, sizeof(effect_uuid_t)) == 0) {
150 ALOGI("found effect \"%s\" from %s",
151 dwnmFxDesc.name, dwnmFxDesc.implementor);
152 isMultichannelCapable = true;
153 break;
154 }
155 }
156 }
157 ALOGE_IF(!isMultichannelCapable, "unable to find downmix effect");
Mathias Agopian65ab4712010-07-14 17:59:35 -0700158}
159
Glenn Kastenc5ac4cb2011-12-12 09:05:55 -0800160AudioMixer::~AudioMixer()
161{
162 track_t* t = mState.tracks;
Glenn Kastenbf71f1e2011-12-13 11:52:35 -0800163 for (unsigned i=0 ; i < MAX_NUM_TRACKS ; i++) {
Glenn Kastenc5ac4cb2011-12-12 09:05:55 -0800164 delete t->resampler;
Jean-Michel Trivi9bd23222012-04-16 13:43:48 -0700165 delete t->downmixerBufferProvider;
Glenn Kastenc5ac4cb2011-12-12 09:05:55 -0800166 t++;
167 }
168 delete [] mState.outputTemp;
169 delete [] mState.resampleTemp;
170}
Mathias Agopian65ab4712010-07-14 17:59:35 -0700171
Jean-Michel Trivia59d2712012-09-12 15:47:07 -0700172int AudioMixer::getTrackName(audio_channel_mask_t channelMask, int sessionId)
Glenn Kastenc5ac4cb2011-12-12 09:05:55 -0800173{
Glenn Kasten5c94b6c2012-03-20 17:01:29 -0700174 uint32_t names = (~mTrackNames) & mConfiguredNames;
Glenn Kasten98dd5422011-12-15 14:38:29 -0800175 if (names != 0) {
176 int n = __builtin_ctz(names);
Steve Block3856b092011-10-20 11:56:00 +0100177 ALOGV("add track (%d)", n);
Glenn Kasten98dd5422011-12-15 14:38:29 -0800178 mTrackNames |= 1 << n;
Glenn Kastendeeb1282012-03-25 11:59:31 -0700179 // assume default parameters for the track, except where noted below
180 track_t* t = &mState.tracks[n];
181 t->needs = 0;
182 t->volume[0] = UNITY_GAIN;
183 t->volume[1] = UNITY_GAIN;
184 // no initialization needed
185 // t->prevVolume[0]
186 // t->prevVolume[1]
187 t->volumeInc[0] = 0;
188 t->volumeInc[1] = 0;
189 t->auxLevel = 0;
190 t->auxInc = 0;
191 // no initialization needed
192 // t->prevAuxLevel
193 // t->frameCount
194 t->channelCount = 2;
195 t->enabled = false;
196 t->format = 16;
197 t->channelMask = AUDIO_CHANNEL_OUT_STEREO;
Jean-Michel Trivia59d2712012-09-12 15:47:07 -0700198 t->sessionId = sessionId;
Glenn Kastendeeb1282012-03-25 11:59:31 -0700199 // setBufferProvider(name, AudioBufferProvider *) is required before enable(name)
200 t->bufferProvider = NULL;
201 t->buffer.raw = NULL;
202 // no initialization needed
203 // t->buffer.frameCount
204 t->hook = NULL;
205 t->in = NULL;
206 t->resampler = NULL;
207 t->sampleRate = mSampleRate;
208 // setParameter(name, TRACK, MAIN_BUFFER, mixBuffer) is required before enable(name)
209 t->mainBuffer = NULL;
210 t->auxBuffer = NULL;
Glenn Kasten52008f82012-03-18 09:34:41 -0700211 t->downmixerBufferProvider = NULL;
Jean-Michel Trivi9bd23222012-04-16 13:43:48 -0700212
213 status_t status = initTrackDownmix(&mState.tracks[n], n, channelMask);
214 if (status == OK) {
215 return TRACK0 + n;
216 }
217 ALOGE("AudioMixer::getTrackName(0x%x) failed, error preparing track for downmix",
218 channelMask);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700219 }
220 return -1;
Glenn Kastenc5ac4cb2011-12-12 09:05:55 -0800221}
Mathias Agopian65ab4712010-07-14 17:59:35 -0700222
Glenn Kastenc5ac4cb2011-12-12 09:05:55 -0800223void AudioMixer::invalidateState(uint32_t mask)
224{
Mathias Agopian65ab4712010-07-14 17:59:35 -0700225 if (mask) {
226 mState.needsChanged |= mask;
227 mState.hook = process__validate;
228 }
229 }
230
Jean-Michel Trivi9bd23222012-04-16 13:43:48 -0700231status_t AudioMixer::initTrackDownmix(track_t* pTrack, int trackNum, audio_channel_mask_t mask)
232{
233 uint32_t channelCount = popcount(mask);
234 ALOG_ASSERT((channelCount <= MAX_NUM_CHANNELS_TO_DOWNMIX) && channelCount);
235 status_t status = OK;
236 if (channelCount > MAX_NUM_CHANNELS) {
237 pTrack->channelMask = mask;
238 pTrack->channelCount = channelCount;
239 ALOGV("initTrackDownmix(track=%d, mask=0x%x) calls prepareTrackForDownmix()",
240 trackNum, mask);
241 status = prepareTrackForDownmix(pTrack, trackNum);
242 } else {
243 unprepareTrackForDownmix(pTrack, trackNum);
244 }
245 return status;
246}
247
248void AudioMixer::unprepareTrackForDownmix(track_t* pTrack, int trackName) {
249 ALOGV("AudioMixer::unprepareTrackForDownmix(%d)", trackName);
250
251 if (pTrack->downmixerBufferProvider != NULL) {
252 // this track had previously been configured with a downmixer, delete it
253 ALOGV(" deleting old downmixer");
254 pTrack->bufferProvider = pTrack->downmixerBufferProvider->mTrackBufferProvider;
255 delete pTrack->downmixerBufferProvider;
256 pTrack->downmixerBufferProvider = NULL;
257 } else {
258 ALOGV(" nothing to do, no downmixer to delete");
259 }
260}
261
Jean-Michel Trivi7d5b2622012-04-04 18:54:36 -0700262status_t AudioMixer::prepareTrackForDownmix(track_t* pTrack, int trackName)
263{
264 ALOGV("AudioMixer::prepareTrackForDownmix(%d) with mask 0x%x", trackName, pTrack->channelMask);
265
Jean-Michel Trivi9bd23222012-04-16 13:43:48 -0700266 // discard the previous downmixer if there was one
267 unprepareTrackForDownmix(pTrack, trackName);
Jean-Michel Trivi7d5b2622012-04-04 18:54:36 -0700268
269 DownmixerBufferProvider* pDbp = new DownmixerBufferProvider();
270 int32_t status;
271
272 if (!isMultichannelCapable) {
273 ALOGE("prepareTrackForDownmix(%d) fails: mixer doesn't support multichannel content",
274 trackName);
275 goto noDownmixForActiveTrack;
276 }
277
278 if (EffectCreate(&dwnmFxDesc.uuid,
Jean-Michel Trivia59d2712012-09-12 15:47:07 -0700279 pTrack->sessionId /*sessionId*/, -2 /*ioId not relevant here, using random value*/,
Jean-Michel Trivi7d5b2622012-04-04 18:54:36 -0700280 &pDbp->mDownmixHandle/*pHandle*/) != 0) {
281 ALOGE("prepareTrackForDownmix(%d) fails: error creating downmixer effect", trackName);
282 goto noDownmixForActiveTrack;
283 }
284
285 // channel input configuration will be overridden per-track
286 pDbp->mDownmixConfig.inputCfg.channels = pTrack->channelMask;
287 pDbp->mDownmixConfig.outputCfg.channels = AUDIO_CHANNEL_OUT_STEREO;
288 pDbp->mDownmixConfig.inputCfg.format = AUDIO_FORMAT_PCM_16_BIT;
289 pDbp->mDownmixConfig.outputCfg.format = AUDIO_FORMAT_PCM_16_BIT;
290 pDbp->mDownmixConfig.inputCfg.samplingRate = pTrack->sampleRate;
291 pDbp->mDownmixConfig.outputCfg.samplingRate = pTrack->sampleRate;
292 pDbp->mDownmixConfig.inputCfg.accessMode = EFFECT_BUFFER_ACCESS_READ;
293 pDbp->mDownmixConfig.outputCfg.accessMode = EFFECT_BUFFER_ACCESS_WRITE;
294 // input and output buffer provider, and frame count will not be used as the downmix effect
295 // process() function is called directly (see DownmixerBufferProvider::getNextBuffer())
296 pDbp->mDownmixConfig.inputCfg.mask = EFFECT_CONFIG_SMP_RATE | EFFECT_CONFIG_CHANNELS |
297 EFFECT_CONFIG_FORMAT | EFFECT_CONFIG_ACC_MODE;
298 pDbp->mDownmixConfig.outputCfg.mask = pDbp->mDownmixConfig.inputCfg.mask;
299
300 {// scope for local variables that are not used in goto label "noDownmixForActiveTrack"
301 int cmdStatus;
302 uint32_t replySize = sizeof(int);
303
304 // Configure and enable downmixer
305 status = (*pDbp->mDownmixHandle)->command(pDbp->mDownmixHandle,
306 EFFECT_CMD_SET_CONFIG /*cmdCode*/, sizeof(effect_config_t) /*cmdSize*/,
307 &pDbp->mDownmixConfig /*pCmdData*/,
308 &replySize /*replySize*/, &cmdStatus /*pReplyData*/);
309 if ((status != 0) || (cmdStatus != 0)) {
310 ALOGE("error %d while configuring downmixer for track %d", status, trackName);
311 goto noDownmixForActiveTrack;
312 }
313 replySize = sizeof(int);
314 status = (*pDbp->mDownmixHandle)->command(pDbp->mDownmixHandle,
315 EFFECT_CMD_ENABLE /*cmdCode*/, 0 /*cmdSize*/, NULL /*pCmdData*/,
316 &replySize /*replySize*/, &cmdStatus /*pReplyData*/);
317 if ((status != 0) || (cmdStatus != 0)) {
318 ALOGE("error %d while enabling downmixer for track %d", status, trackName);
319 goto noDownmixForActiveTrack;
320 }
321
322 // Set downmix type
323 // parameter size rounded for padding on 32bit boundary
324 const int psizePadded = ((sizeof(downmix_params_t) - 1)/sizeof(int) + 1) * sizeof(int);
325 const int downmixParamSize =
326 sizeof(effect_param_t) + psizePadded + sizeof(downmix_type_t);
327 effect_param_t * const param = (effect_param_t *) malloc(downmixParamSize);
328 param->psize = sizeof(downmix_params_t);
329 const downmix_params_t downmixParam = DOWNMIX_PARAM_TYPE;
330 memcpy(param->data, &downmixParam, param->psize);
331 const downmix_type_t downmixType = DOWNMIX_TYPE_FOLD;
332 param->vsize = sizeof(downmix_type_t);
333 memcpy(param->data + psizePadded, &downmixType, param->vsize);
334
335 status = (*pDbp->mDownmixHandle)->command(pDbp->mDownmixHandle,
336 EFFECT_CMD_SET_PARAM /* cmdCode */, downmixParamSize/* cmdSize */,
337 param /*pCmndData*/, &replySize /*replySize*/, &cmdStatus /*pReplyData*/);
338
339 free(param);
340
341 if ((status != 0) || (cmdStatus != 0)) {
342 ALOGE("error %d while setting downmix type for track %d", status, trackName);
343 goto noDownmixForActiveTrack;
344 } else {
345 ALOGV("downmix type set to %d for track %d", (int) downmixType, trackName);
346 }
347 }// end of scope for local variables that are not used in goto label "noDownmixForActiveTrack"
348
349 // initialization successful:
350 // - keep track of the real buffer provider in case it was set before
351 pDbp->mTrackBufferProvider = pTrack->bufferProvider;
352 // - we'll use the downmix effect integrated inside this
353 // track's buffer provider, and we'll use it as the track's buffer provider
354 pTrack->downmixerBufferProvider = pDbp;
355 pTrack->bufferProvider = pDbp;
356
357 return NO_ERROR;
358
359noDownmixForActiveTrack:
360 delete pDbp;
361 pTrack->downmixerBufferProvider = NULL;
362 return NO_INIT;
363}
364
Glenn Kastenc5ac4cb2011-12-12 09:05:55 -0800365void AudioMixer::deleteTrackName(int name)
366{
Jean-Michel Trivi9bd23222012-04-16 13:43:48 -0700367 ALOGV("AudioMixer::deleteTrackName(%d)", name);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700368 name -= TRACK0;
Glenn Kasten5798d4e2012-03-08 12:18:35 -0800369 ALOG_ASSERT(uint32_t(name) < MAX_NUM_TRACKS, "bad track name %d", name);
Glenn Kasten237a6242011-12-15 15:32:27 -0800370 ALOGV("deleteTrackName(%d)", name);
371 track_t& track(mState.tracks[ name ]);
Glenn Kasten4c340c62012-01-27 12:33:54 -0800372 if (track.enabled) {
373 track.enabled = false;
Glenn Kasten237a6242011-12-15 15:32:27 -0800374 invalidateState(1<<name);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700375 }
Glenn Kasten4e2293f2012-04-12 09:39:07 -0700376 // delete the resampler
377 delete track.resampler;
378 track.resampler = NULL;
Jean-Michel Trivi9bd23222012-04-16 13:43:48 -0700379 // delete the downmixer
380 unprepareTrackForDownmix(&mState.tracks[name], name);
381
Glenn Kasten237a6242011-12-15 15:32:27 -0800382 mTrackNames &= ~(1<<name);
Glenn Kastenc5ac4cb2011-12-12 09:05:55 -0800383}
Mathias Agopian65ab4712010-07-14 17:59:35 -0700384
Glenn Kasten9c56d4a2011-12-19 15:06:39 -0800385void AudioMixer::enable(int name)
Mathias Agopian65ab4712010-07-14 17:59:35 -0700386{
Glenn Kasten9c56d4a2011-12-19 15:06:39 -0800387 name -= TRACK0;
Glenn Kasten5798d4e2012-03-08 12:18:35 -0800388 ALOG_ASSERT(uint32_t(name) < MAX_NUM_TRACKS, "bad track name %d", name);
Glenn Kasten9c56d4a2011-12-19 15:06:39 -0800389 track_t& track = mState.tracks[name];
390
Glenn Kasten4c340c62012-01-27 12:33:54 -0800391 if (!track.enabled) {
392 track.enabled = true;
Glenn Kasten9c56d4a2011-12-19 15:06:39 -0800393 ALOGV("enable(%d)", name);
394 invalidateState(1 << name);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700395 }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700396}
397
Glenn Kasten9c56d4a2011-12-19 15:06:39 -0800398void AudioMixer::disable(int name)
Mathias Agopian65ab4712010-07-14 17:59:35 -0700399{
Glenn Kasten9c56d4a2011-12-19 15:06:39 -0800400 name -= TRACK0;
Glenn Kasten5798d4e2012-03-08 12:18:35 -0800401 ALOG_ASSERT(uint32_t(name) < MAX_NUM_TRACKS, "bad track name %d", name);
Glenn Kasten9c56d4a2011-12-19 15:06:39 -0800402 track_t& track = mState.tracks[name];
403
Glenn Kasten4c340c62012-01-27 12:33:54 -0800404 if (track.enabled) {
405 track.enabled = false;
Glenn Kasten9c56d4a2011-12-19 15:06:39 -0800406 ALOGV("disable(%d)", name);
407 invalidateState(1 << name);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700408 }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700409}
410
Glenn Kasten9c56d4a2011-12-19 15:06:39 -0800411void AudioMixer::setParameter(int name, int target, int param, void *value)
Mathias Agopian65ab4712010-07-14 17:59:35 -0700412{
Glenn Kasten9c56d4a2011-12-19 15:06:39 -0800413 name -= TRACK0;
Glenn Kasten5798d4e2012-03-08 12:18:35 -0800414 ALOG_ASSERT(uint32_t(name) < MAX_NUM_TRACKS, "bad track name %d", name);
Glenn Kasten9c56d4a2011-12-19 15:06:39 -0800415 track_t& track = mState.tracks[name];
Mathias Agopian65ab4712010-07-14 17:59:35 -0700416
Mathias Agopian65ab4712010-07-14 17:59:35 -0700417 int valueInt = (int)value;
418 int32_t *valueBuf = (int32_t *)value;
419
420 switch (target) {
Glenn Kasten788040c2011-05-05 08:19:00 -0700421
Mathias Agopian65ab4712010-07-14 17:59:35 -0700422 case TRACK:
Glenn Kasten9c56d4a2011-12-19 15:06:39 -0800423 switch (param) {
Glenn Kasten788040c2011-05-05 08:19:00 -0700424 case CHANNEL_MASK: {
Glenn Kasten254af182012-07-03 14:59:05 -0700425 audio_channel_mask_t mask = (audio_channel_mask_t) value;
Glenn Kasten9c56d4a2011-12-19 15:06:39 -0800426 if (track.channelMask != mask) {
Glenn Kasten5798d4e2012-03-08 12:18:35 -0800427 uint32_t channelCount = popcount(mask);
Jean-Michel Trivi7d5b2622012-04-04 18:54:36 -0700428 ALOG_ASSERT((channelCount <= MAX_NUM_CHANNELS_TO_DOWNMIX) && channelCount);
Glenn Kasten9c56d4a2011-12-19 15:06:39 -0800429 track.channelMask = mask;
430 track.channelCount = channelCount;
Jean-Michel Trivi9bd23222012-04-16 13:43:48 -0700431 // the mask has changed, does this track need a downmixer?
432 initTrackDownmix(&mState.tracks[name], name, mask);
Glenn Kasten788040c2011-05-05 08:19:00 -0700433 ALOGV("setParameter(TRACK, CHANNEL_MASK, %x)", mask);
Glenn Kasten9c56d4a2011-12-19 15:06:39 -0800434 invalidateState(1 << name);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700435 }
Glenn Kasten788040c2011-05-05 08:19:00 -0700436 } break;
437 case MAIN_BUFFER:
Glenn Kasten9c56d4a2011-12-19 15:06:39 -0800438 if (track.mainBuffer != valueBuf) {
439 track.mainBuffer = valueBuf;
Steve Block3856b092011-10-20 11:56:00 +0100440 ALOGV("setParameter(TRACK, MAIN_BUFFER, %p)", valueBuf);
Glenn Kasten9c56d4a2011-12-19 15:06:39 -0800441 invalidateState(1 << name);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700442 }
Glenn Kasten788040c2011-05-05 08:19:00 -0700443 break;
444 case AUX_BUFFER:
Glenn Kasten9c56d4a2011-12-19 15:06:39 -0800445 if (track.auxBuffer != valueBuf) {
446 track.auxBuffer = valueBuf;
Steve Block3856b092011-10-20 11:56:00 +0100447 ALOGV("setParameter(TRACK, AUX_BUFFER, %p)", valueBuf);
Glenn Kasten9c56d4a2011-12-19 15:06:39 -0800448 invalidateState(1 << name);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700449 }
Glenn Kasten788040c2011-05-05 08:19:00 -0700450 break;
Glenn Kastendeeb1282012-03-25 11:59:31 -0700451 case FORMAT:
452 ALOG_ASSERT(valueInt == AUDIO_FORMAT_PCM_16_BIT);
453 break;
Jean-Michel Trivi7d5b2622012-04-04 18:54:36 -0700454 // FIXME do we want to support setting the downmix type from AudioFlinger?
455 // for a specific track? or per mixer?
456 /* case DOWNMIX_TYPE:
457 break */
Glenn Kasten788040c2011-05-05 08:19:00 -0700458 default:
Glenn Kasten5798d4e2012-03-08 12:18:35 -0800459 LOG_FATAL("bad param");
Mathias Agopian65ab4712010-07-14 17:59:35 -0700460 }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700461 break;
Glenn Kasten788040c2011-05-05 08:19:00 -0700462
Mathias Agopian65ab4712010-07-14 17:59:35 -0700463 case RESAMPLE:
Glenn Kasten9c56d4a2011-12-19 15:06:39 -0800464 switch (param) {
465 case SAMPLE_RATE:
Glenn Kasten5798d4e2012-03-08 12:18:35 -0800466 ALOG_ASSERT(valueInt > 0, "bad sample rate %d", valueInt);
Glenn Kasten788040c2011-05-05 08:19:00 -0700467 if (track.setResampler(uint32_t(valueInt), mSampleRate)) {
468 ALOGV("setParameter(RESAMPLE, SAMPLE_RATE, %u)",
469 uint32_t(valueInt));
Glenn Kasten9c56d4a2011-12-19 15:06:39 -0800470 invalidateState(1 << name);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700471 }
Glenn Kasten9c56d4a2011-12-19 15:06:39 -0800472 break;
473 case RESET:
Eric Laurent243f5f92011-02-28 16:52:51 -0800474 track.resetResampler();
Glenn Kasten9c56d4a2011-12-19 15:06:39 -0800475 invalidateState(1 << name);
476 break;
Glenn Kasten4e2293f2012-04-12 09:39:07 -0700477 case REMOVE:
478 delete track.resampler;
479 track.resampler = NULL;
480 track.sampleRate = mSampleRate;
481 invalidateState(1 << name);
482 break;
Glenn Kasten788040c2011-05-05 08:19:00 -0700483 default:
Glenn Kasten5798d4e2012-03-08 12:18:35 -0800484 LOG_FATAL("bad param");
Eric Laurent243f5f92011-02-28 16:52:51 -0800485 }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700486 break;
Glenn Kasten788040c2011-05-05 08:19:00 -0700487
Mathias Agopian65ab4712010-07-14 17:59:35 -0700488 case RAMP_VOLUME:
489 case VOLUME:
Glenn Kasten9c56d4a2011-12-19 15:06:39 -0800490 switch (param) {
Glenn Kasten788040c2011-05-05 08:19:00 -0700491 case VOLUME0:
Glenn Kasten9c56d4a2011-12-19 15:06:39 -0800492 case VOLUME1:
493 if (track.volume[param-VOLUME0] != valueInt) {
Steve Block3856b092011-10-20 11:56:00 +0100494 ALOGV("setParameter(VOLUME, VOLUME0/1: %04x)", valueInt);
Glenn Kasten9c56d4a2011-12-19 15:06:39 -0800495 track.prevVolume[param-VOLUME0] = track.volume[param-VOLUME0] << 16;
496 track.volume[param-VOLUME0] = valueInt;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700497 if (target == VOLUME) {
Glenn Kasten9c56d4a2011-12-19 15:06:39 -0800498 track.prevVolume[param-VOLUME0] = valueInt << 16;
499 track.volumeInc[param-VOLUME0] = 0;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700500 } else {
Glenn Kasten9c56d4a2011-12-19 15:06:39 -0800501 int32_t d = (valueInt<<16) - track.prevVolume[param-VOLUME0];
Mathias Agopian65ab4712010-07-14 17:59:35 -0700502 int32_t volInc = d / int32_t(mState.frameCount);
Glenn Kasten9c56d4a2011-12-19 15:06:39 -0800503 track.volumeInc[param-VOLUME0] = volInc;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700504 if (volInc == 0) {
Glenn Kasten9c56d4a2011-12-19 15:06:39 -0800505 track.prevVolume[param-VOLUME0] = valueInt << 16;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700506 }
507 }
Glenn Kasten9c56d4a2011-12-19 15:06:39 -0800508 invalidateState(1 << name);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700509 }
Glenn Kasten9c56d4a2011-12-19 15:06:39 -0800510 break;
511 case AUXLEVEL:
Glenn Kasten5798d4e2012-03-08 12:18:35 -0800512 //ALOG_ASSERT(0 <= valueInt && valueInt <= MAX_GAIN_INT, "bad aux level %d", valueInt);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700513 if (track.auxLevel != valueInt) {
Steve Block3856b092011-10-20 11:56:00 +0100514 ALOGV("setParameter(VOLUME, AUXLEVEL: %04x)", valueInt);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700515 track.prevAuxLevel = track.auxLevel << 16;
516 track.auxLevel = valueInt;
517 if (target == VOLUME) {
518 track.prevAuxLevel = valueInt << 16;
519 track.auxInc = 0;
520 } else {
521 int32_t d = (valueInt<<16) - track.prevAuxLevel;
522 int32_t volInc = d / int32_t(mState.frameCount);
523 track.auxInc = volInc;
524 if (volInc == 0) {
525 track.prevAuxLevel = valueInt << 16;
526 }
527 }
Glenn Kasten9c56d4a2011-12-19 15:06:39 -0800528 invalidateState(1 << name);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700529 }
Glenn Kasten9c56d4a2011-12-19 15:06:39 -0800530 break;
Glenn Kasten788040c2011-05-05 08:19:00 -0700531 default:
Glenn Kasten5798d4e2012-03-08 12:18:35 -0800532 LOG_FATAL("bad param");
Mathias Agopian65ab4712010-07-14 17:59:35 -0700533 }
534 break;
Glenn Kasten788040c2011-05-05 08:19:00 -0700535
536 default:
Glenn Kasten5798d4e2012-03-08 12:18:35 -0800537 LOG_FATAL("bad target");
Mathias Agopian65ab4712010-07-14 17:59:35 -0700538 }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700539}
540
541bool AudioMixer::track_t::setResampler(uint32_t value, uint32_t devSampleRate)
542{
Glenn Kasten4e2293f2012-04-12 09:39:07 -0700543 if (value != devSampleRate || resampler != NULL) {
Mathias Agopian65ab4712010-07-14 17:59:35 -0700544 if (sampleRate != value) {
545 sampleRate = value;
Glenn Kastene0feee32011-12-13 11:53:26 -0800546 if (resampler == NULL) {
Glenn Kastena6d41332012-10-01 14:04:31 -0700547 ALOGV("creating resampler from track %d Hz to device %d Hz", value, devSampleRate);
548 AudioResampler::src_quality quality;
549 // force lowest quality level resampler if use case isn't music or video
550 // FIXME this is flawed for dynamic sample rates, as we choose the resampler
551 // quality level based on the initial ratio, but that could change later.
552 // Should have a way to distinguish tracks with static ratios vs. dynamic ratios.
553 if (!((value == 44100 && devSampleRate == 48000) ||
554 (value == 48000 && devSampleRate == 44100))) {
555 quality = AudioResampler::LOW_QUALITY;
556 } else {
557 quality = AudioResampler::DEFAULT_QUALITY;
558 }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700559 resampler = AudioResampler::create(
Jean-Michel Triviacb86cc2012-04-16 12:43:57 -0700560 format,
561 // the resampler sees the number of channels after the downmixer, if any
562 downmixerBufferProvider != NULL ? MAX_NUM_CHANNELS : channelCount,
Glenn Kastena6d41332012-10-01 14:04:31 -0700563 devSampleRate, quality);
Glenn Kasten52008f82012-03-18 09:34:41 -0700564 resampler->setLocalTimeFreq(sLocalTimeFreq);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700565 }
566 return true;
567 }
568 }
569 return false;
570}
571
Mathias Agopian65ab4712010-07-14 17:59:35 -0700572inline
573void AudioMixer::track_t::adjustVolumeRamp(bool aux)
574{
Glenn Kastenf9a27772012-01-06 07:47:26 -0800575 for (uint32_t i=0 ; i<MAX_NUM_CHANNELS ; i++) {
Mathias Agopian65ab4712010-07-14 17:59:35 -0700576 if (((volumeInc[i]>0) && (((prevVolume[i]+volumeInc[i])>>16) >= volume[i])) ||
577 ((volumeInc[i]<0) && (((prevVolume[i]+volumeInc[i])>>16) <= volume[i]))) {
578 volumeInc[i] = 0;
579 prevVolume[i] = volume[i]<<16;
580 }
581 }
582 if (aux) {
583 if (((auxInc>0) && (((prevAuxLevel+auxInc)>>16) >= auxLevel)) ||
584 ((auxInc<0) && (((prevAuxLevel+auxInc)>>16) <= auxLevel))) {
585 auxInc = 0;
586 prevAuxLevel = auxLevel<<16;
587 }
588 }
589}
590
Glenn Kastenc59c0042012-02-02 14:06:11 -0800591size_t AudioMixer::getUnreleasedFrames(int name) const
Eric Laurent071ccd52011-12-22 16:08:41 -0800592{
593 name -= TRACK0;
594 if (uint32_t(name) < MAX_NUM_TRACKS) {
Glenn Kastenc59c0042012-02-02 14:06:11 -0800595 return mState.tracks[name].getUnreleasedFrames();
Eric Laurent071ccd52011-12-22 16:08:41 -0800596 }
597 return 0;
598}
Mathias Agopian65ab4712010-07-14 17:59:35 -0700599
Glenn Kasten01c4ebf2012-02-22 10:47:35 -0800600void AudioMixer::setBufferProvider(int name, AudioBufferProvider* bufferProvider)
Mathias Agopian65ab4712010-07-14 17:59:35 -0700601{
Glenn Kasten9c56d4a2011-12-19 15:06:39 -0800602 name -= TRACK0;
Glenn Kasten5798d4e2012-03-08 12:18:35 -0800603 ALOG_ASSERT(uint32_t(name) < MAX_NUM_TRACKS, "bad track name %d", name);
Jean-Michel Trivi7d5b2622012-04-04 18:54:36 -0700604
605 if (mState.tracks[name].downmixerBufferProvider != NULL) {
606 // update required?
607 if (mState.tracks[name].downmixerBufferProvider->mTrackBufferProvider != bufferProvider) {
608 ALOGV("AudioMixer::setBufferProvider(%p) for downmix", bufferProvider);
609 // setting the buffer provider for a track that gets downmixed consists in:
610 // 1/ setting the buffer provider to the "downmix / buffer provider" wrapper
611 // so it's the one that gets called when the buffer provider is needed,
612 mState.tracks[name].bufferProvider = mState.tracks[name].downmixerBufferProvider;
613 // 2/ saving the buffer provider for the track so the wrapper can use it
614 // when it downmixes.
615 mState.tracks[name].downmixerBufferProvider->mTrackBufferProvider = bufferProvider;
616 }
617 } else {
618 mState.tracks[name].bufferProvider = bufferProvider;
619 }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700620}
621
622
623
John Grossman4ff14ba2012-02-08 16:37:41 -0800624void AudioMixer::process(int64_t pts)
Mathias Agopian65ab4712010-07-14 17:59:35 -0700625{
John Grossman4ff14ba2012-02-08 16:37:41 -0800626 mState.hook(&mState, pts);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700627}
628
629
John Grossman4ff14ba2012-02-08 16:37:41 -0800630void AudioMixer::process__validate(state_t* state, int64_t pts)
Mathias Agopian65ab4712010-07-14 17:59:35 -0700631{
Steve Block5ff1dd52012-01-05 23:22:43 +0000632 ALOGW_IF(!state->needsChanged,
Mathias Agopian65ab4712010-07-14 17:59:35 -0700633 "in process__validate() but nothing's invalid");
634
635 uint32_t changed = state->needsChanged;
636 state->needsChanged = 0; // clear the validation flag
637
638 // recompute which tracks are enabled / disabled
639 uint32_t enabled = 0;
640 uint32_t disabled = 0;
641 while (changed) {
642 const int i = 31 - __builtin_clz(changed);
643 const uint32_t mask = 1<<i;
644 changed &= ~mask;
645 track_t& t = state->tracks[i];
646 (t.enabled ? enabled : disabled) |= mask;
647 }
648 state->enabledTracks &= ~disabled;
649 state->enabledTracks |= enabled;
650
651 // compute everything we need...
652 int countActiveTracks = 0;
Glenn Kasten4c340c62012-01-27 12:33:54 -0800653 bool all16BitsStereoNoResample = true;
654 bool resampling = false;
655 bool volumeRamp = false;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700656 uint32_t en = state->enabledTracks;
657 while (en) {
658 const int i = 31 - __builtin_clz(en);
659 en &= ~(1<<i);
660
661 countActiveTracks++;
662 track_t& t = state->tracks[i];
663 uint32_t n = 0;
664 n |= NEEDS_CHANNEL_1 + t.channelCount - 1;
665 n |= NEEDS_FORMAT_16;
666 n |= t.doesResample() ? NEEDS_RESAMPLE_ENABLED : NEEDS_RESAMPLE_DISABLED;
667 if (t.auxLevel != 0 && t.auxBuffer != NULL) {
668 n |= NEEDS_AUX_ENABLED;
669 }
670
671 if (t.volumeInc[0]|t.volumeInc[1]) {
Glenn Kasten4c340c62012-01-27 12:33:54 -0800672 volumeRamp = true;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700673 } else if (!t.doesResample() && t.volumeRL == 0) {
674 n |= NEEDS_MUTE_ENABLED;
675 }
676 t.needs = n;
677
678 if ((n & NEEDS_MUTE__MASK) == NEEDS_MUTE_ENABLED) {
679 t.hook = track__nop;
680 } else {
681 if ((n & NEEDS_AUX__MASK) == NEEDS_AUX_ENABLED) {
Glenn Kasten4c340c62012-01-27 12:33:54 -0800682 all16BitsStereoNoResample = false;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700683 }
684 if ((n & NEEDS_RESAMPLE__MASK) == NEEDS_RESAMPLE_ENABLED) {
Glenn Kasten4c340c62012-01-27 12:33:54 -0800685 all16BitsStereoNoResample = false;
686 resampling = true;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700687 t.hook = track__genericResample;
Jean-Michel Trivi7d5b2622012-04-04 18:54:36 -0700688 ALOGV_IF((n & NEEDS_CHANNEL_COUNT__MASK) > NEEDS_CHANNEL_2,
Jean-Michel Trivi9bd23222012-04-16 13:43:48 -0700689 "Track %d needs downmix + resample", i);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700690 } else {
691 if ((n & NEEDS_CHANNEL_COUNT__MASK) == NEEDS_CHANNEL_1){
692 t.hook = track__16BitsMono;
Glenn Kasten4c340c62012-01-27 12:33:54 -0800693 all16BitsStereoNoResample = false;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700694 }
Jean-Michel Trivi7d5b2622012-04-04 18:54:36 -0700695 if ((n & NEEDS_CHANNEL_COUNT__MASK) >= NEEDS_CHANNEL_2){
Mathias Agopian65ab4712010-07-14 17:59:35 -0700696 t.hook = track__16BitsStereo;
Jean-Michel Trivi7d5b2622012-04-04 18:54:36 -0700697 ALOGV_IF((n & NEEDS_CHANNEL_COUNT__MASK) > NEEDS_CHANNEL_2,
Jean-Michel Trivi9bd23222012-04-16 13:43:48 -0700698 "Track %d needs downmix", i);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700699 }
700 }
701 }
702 }
703
704 // select the processing hooks
705 state->hook = process__nop;
706 if (countActiveTracks) {
707 if (resampling) {
708 if (!state->outputTemp) {
709 state->outputTemp = new int32_t[MAX_NUM_CHANNELS * state->frameCount];
710 }
711 if (!state->resampleTemp) {
712 state->resampleTemp = new int32_t[MAX_NUM_CHANNELS * state->frameCount];
713 }
714 state->hook = process__genericResampling;
715 } else {
716 if (state->outputTemp) {
717 delete [] state->outputTemp;
Glenn Kastene0feee32011-12-13 11:53:26 -0800718 state->outputTemp = NULL;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700719 }
720 if (state->resampleTemp) {
721 delete [] state->resampleTemp;
Glenn Kastene0feee32011-12-13 11:53:26 -0800722 state->resampleTemp = NULL;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700723 }
724 state->hook = process__genericNoResampling;
725 if (all16BitsStereoNoResample && !volumeRamp) {
726 if (countActiveTracks == 1) {
727 state->hook = process__OneTrack16BitsStereoNoResampling;
728 }
729 }
730 }
731 }
732
Steve Block3856b092011-10-20 11:56:00 +0100733 ALOGV("mixer configuration change: %d activeTracks (%08x) "
Mathias Agopian65ab4712010-07-14 17:59:35 -0700734 "all16BitsStereoNoResample=%d, resampling=%d, volumeRamp=%d",
735 countActiveTracks, state->enabledTracks,
736 all16BitsStereoNoResample, resampling, volumeRamp);
737
John Grossman4ff14ba2012-02-08 16:37:41 -0800738 state->hook(state, pts);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700739
Glenn Kastenc5ac4cb2011-12-12 09:05:55 -0800740 // Now that the volume ramp has been done, set optimal state and
741 // track hooks for subsequent mixer process
742 if (countActiveTracks) {
Glenn Kasten4c340c62012-01-27 12:33:54 -0800743 bool allMuted = true;
Glenn Kastenc5ac4cb2011-12-12 09:05:55 -0800744 uint32_t en = state->enabledTracks;
745 while (en) {
746 const int i = 31 - __builtin_clz(en);
747 en &= ~(1<<i);
748 track_t& t = state->tracks[i];
749 if (!t.doesResample() && t.volumeRL == 0)
750 {
751 t.needs |= NEEDS_MUTE_ENABLED;
752 t.hook = track__nop;
753 } else {
Glenn Kasten4c340c62012-01-27 12:33:54 -0800754 allMuted = false;
Glenn Kastenc5ac4cb2011-12-12 09:05:55 -0800755 }
756 }
757 if (allMuted) {
758 state->hook = process__nop;
759 } else if (all16BitsStereoNoResample) {
760 if (countActiveTracks == 1) {
761 state->hook = process__OneTrack16BitsStereoNoResampling;
762 }
763 }
764 }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700765}
766
Mathias Agopian65ab4712010-07-14 17:59:35 -0700767
768void AudioMixer::track__genericResample(track_t* t, int32_t* out, size_t outFrameCount, int32_t* temp, int32_t* aux)
769{
770 t->resampler->setSampleRate(t->sampleRate);
771
772 // ramp gain - resample to temp buffer and scale/mix in 2nd step
773 if (aux != NULL) {
774 // always resample with unity gain when sending to auxiliary buffer to be able
775 // to apply send level after resampling
776 // TODO: modify each resampler to support aux channel?
777 t->resampler->setVolume(UNITY_GAIN, UNITY_GAIN);
778 memset(temp, 0, outFrameCount * MAX_NUM_CHANNELS * sizeof(int32_t));
779 t->resampler->resample(temp, outFrameCount, t->bufferProvider);
Glenn Kastenf6b16782011-12-15 09:51:17 -0800780 if (CC_UNLIKELY(t->volumeInc[0]|t->volumeInc[1]|t->auxInc)) {
Mathias Agopian65ab4712010-07-14 17:59:35 -0700781 volumeRampStereo(t, out, outFrameCount, temp, aux);
782 } else {
783 volumeStereo(t, out, outFrameCount, temp, aux);
784 }
785 } else {
Glenn Kastenf6b16782011-12-15 09:51:17 -0800786 if (CC_UNLIKELY(t->volumeInc[0]|t->volumeInc[1])) {
Mathias Agopian65ab4712010-07-14 17:59:35 -0700787 t->resampler->setVolume(UNITY_GAIN, UNITY_GAIN);
788 memset(temp, 0, outFrameCount * MAX_NUM_CHANNELS * sizeof(int32_t));
789 t->resampler->resample(temp, outFrameCount, t->bufferProvider);
790 volumeRampStereo(t, out, outFrameCount, temp, aux);
791 }
792
793 // constant gain
794 else {
795 t->resampler->setVolume(t->volume[0], t->volume[1]);
796 t->resampler->resample(out, outFrameCount, t->bufferProvider);
797 }
798 }
799}
800
801void AudioMixer::track__nop(track_t* t, int32_t* out, size_t outFrameCount, int32_t* temp, int32_t* aux)
802{
803}
804
805void AudioMixer::volumeRampStereo(track_t* t, int32_t* out, size_t frameCount, int32_t* temp, int32_t* aux)
806{
807 int32_t vl = t->prevVolume[0];
808 int32_t vr = t->prevVolume[1];
809 const int32_t vlInc = t->volumeInc[0];
810 const int32_t vrInc = t->volumeInc[1];
811
Steve Blockb8a80522011-12-20 16:23:08 +0000812 //ALOGD("[0] %p: inc=%f, v0=%f, v1=%d, final=%f, count=%d",
Mathias Agopian65ab4712010-07-14 17:59:35 -0700813 // t, vlInc/65536.0f, vl/65536.0f, t->volume[0],
814 // (vl + vlInc*frameCount)/65536.0f, frameCount);
815
816 // ramp volume
Glenn Kastenf6b16782011-12-15 09:51:17 -0800817 if (CC_UNLIKELY(aux != NULL)) {
Mathias Agopian65ab4712010-07-14 17:59:35 -0700818 int32_t va = t->prevAuxLevel;
819 const int32_t vaInc = t->auxInc;
820 int32_t l;
821 int32_t r;
822
823 do {
824 l = (*temp++ >> 12);
825 r = (*temp++ >> 12);
826 *out++ += (vl >> 16) * l;
827 *out++ += (vr >> 16) * r;
828 *aux++ += (va >> 17) * (l + r);
829 vl += vlInc;
830 vr += vrInc;
831 va += vaInc;
832 } while (--frameCount);
833 t->prevAuxLevel = va;
834 } else {
835 do {
836 *out++ += (vl >> 16) * (*temp++ >> 12);
837 *out++ += (vr >> 16) * (*temp++ >> 12);
838 vl += vlInc;
839 vr += vrInc;
840 } while (--frameCount);
841 }
842 t->prevVolume[0] = vl;
843 t->prevVolume[1] = vr;
Glenn Kastena1117922012-01-26 10:53:32 -0800844 t->adjustVolumeRamp(aux != NULL);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700845}
846
847void AudioMixer::volumeStereo(track_t* t, int32_t* out, size_t frameCount, int32_t* temp, int32_t* aux)
848{
849 const int16_t vl = t->volume[0];
850 const int16_t vr = t->volume[1];
851
Glenn Kastenf6b16782011-12-15 09:51:17 -0800852 if (CC_UNLIKELY(aux != NULL)) {
Glenn Kasten3b81aca2012-01-27 15:26:23 -0800853 const int16_t va = t->auxLevel;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700854 do {
855 int16_t l = (int16_t)(*temp++ >> 12);
856 int16_t r = (int16_t)(*temp++ >> 12);
857 out[0] = mulAdd(l, vl, out[0]);
858 int16_t a = (int16_t)(((int32_t)l + r) >> 1);
859 out[1] = mulAdd(r, vr, out[1]);
860 out += 2;
861 aux[0] = mulAdd(a, va, aux[0]);
862 aux++;
863 } while (--frameCount);
864 } else {
865 do {
866 int16_t l = (int16_t)(*temp++ >> 12);
867 int16_t r = (int16_t)(*temp++ >> 12);
868 out[0] = mulAdd(l, vl, out[0]);
869 out[1] = mulAdd(r, vr, out[1]);
870 out += 2;
871 } while (--frameCount);
872 }
873}
874
875void AudioMixer::track__16BitsStereo(track_t* t, int32_t* out, size_t frameCount, int32_t* temp, int32_t* aux)
876{
Glenn Kasten54c3b662012-01-06 07:46:30 -0800877 const int16_t *in = static_cast<const int16_t *>(t->in);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700878
Glenn Kastenf6b16782011-12-15 09:51:17 -0800879 if (CC_UNLIKELY(aux != NULL)) {
Mathias Agopian65ab4712010-07-14 17:59:35 -0700880 int32_t l;
881 int32_t r;
882 // ramp gain
Glenn Kastenf6b16782011-12-15 09:51:17 -0800883 if (CC_UNLIKELY(t->volumeInc[0]|t->volumeInc[1]|t->auxInc)) {
Mathias Agopian65ab4712010-07-14 17:59:35 -0700884 int32_t vl = t->prevVolume[0];
885 int32_t vr = t->prevVolume[1];
886 int32_t va = t->prevAuxLevel;
887 const int32_t vlInc = t->volumeInc[0];
888 const int32_t vrInc = t->volumeInc[1];
889 const int32_t vaInc = t->auxInc;
Steve Blockb8a80522011-12-20 16:23:08 +0000890 // ALOGD("[1] %p: inc=%f, v0=%f, v1=%d, final=%f, count=%d",
Mathias Agopian65ab4712010-07-14 17:59:35 -0700891 // t, vlInc/65536.0f, vl/65536.0f, t->volume[0],
892 // (vl + vlInc*frameCount)/65536.0f, frameCount);
893
894 do {
895 l = (int32_t)*in++;
896 r = (int32_t)*in++;
897 *out++ += (vl >> 16) * l;
898 *out++ += (vr >> 16) * r;
899 *aux++ += (va >> 17) * (l + r);
900 vl += vlInc;
901 vr += vrInc;
902 va += vaInc;
903 } while (--frameCount);
904
905 t->prevVolume[0] = vl;
906 t->prevVolume[1] = vr;
907 t->prevAuxLevel = va;
908 t->adjustVolumeRamp(true);
909 }
910
911 // constant gain
912 else {
913 const uint32_t vrl = t->volumeRL;
914 const int16_t va = (int16_t)t->auxLevel;
915 do {
Glenn Kasten54c3b662012-01-06 07:46:30 -0800916 uint32_t rl = *reinterpret_cast<const uint32_t *>(in);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700917 int16_t a = (int16_t)(((int32_t)in[0] + in[1]) >> 1);
918 in += 2;
919 out[0] = mulAddRL(1, rl, vrl, out[0]);
920 out[1] = mulAddRL(0, rl, vrl, out[1]);
921 out += 2;
922 aux[0] = mulAdd(a, va, aux[0]);
923 aux++;
924 } while (--frameCount);
925 }
926 } else {
927 // ramp gain
Glenn Kastenf6b16782011-12-15 09:51:17 -0800928 if (CC_UNLIKELY(t->volumeInc[0]|t->volumeInc[1])) {
Mathias Agopian65ab4712010-07-14 17:59:35 -0700929 int32_t vl = t->prevVolume[0];
930 int32_t vr = t->prevVolume[1];
931 const int32_t vlInc = t->volumeInc[0];
932 const int32_t vrInc = t->volumeInc[1];
933
Steve Blockb8a80522011-12-20 16:23:08 +0000934 // ALOGD("[1] %p: inc=%f, v0=%f, v1=%d, final=%f, count=%d",
Mathias Agopian65ab4712010-07-14 17:59:35 -0700935 // t, vlInc/65536.0f, vl/65536.0f, t->volume[0],
936 // (vl + vlInc*frameCount)/65536.0f, frameCount);
937
938 do {
939 *out++ += (vl >> 16) * (int32_t) *in++;
940 *out++ += (vr >> 16) * (int32_t) *in++;
941 vl += vlInc;
942 vr += vrInc;
943 } while (--frameCount);
944
945 t->prevVolume[0] = vl;
946 t->prevVolume[1] = vr;
947 t->adjustVolumeRamp(false);
948 }
949
950 // constant gain
951 else {
952 const uint32_t vrl = t->volumeRL;
953 do {
Glenn Kasten54c3b662012-01-06 07:46:30 -0800954 uint32_t rl = *reinterpret_cast<const uint32_t *>(in);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700955 in += 2;
956 out[0] = mulAddRL(1, rl, vrl, out[0]);
957 out[1] = mulAddRL(0, rl, vrl, out[1]);
958 out += 2;
959 } while (--frameCount);
960 }
961 }
962 t->in = in;
963}
964
965void AudioMixer::track__16BitsMono(track_t* t, int32_t* out, size_t frameCount, int32_t* temp, int32_t* aux)
966{
Glenn Kasten54c3b662012-01-06 07:46:30 -0800967 const int16_t *in = static_cast<int16_t const *>(t->in);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700968
Glenn Kastenf6b16782011-12-15 09:51:17 -0800969 if (CC_UNLIKELY(aux != NULL)) {
Mathias Agopian65ab4712010-07-14 17:59:35 -0700970 // ramp gain
Glenn Kastenf6b16782011-12-15 09:51:17 -0800971 if (CC_UNLIKELY(t->volumeInc[0]|t->volumeInc[1]|t->auxInc)) {
Mathias Agopian65ab4712010-07-14 17:59:35 -0700972 int32_t vl = t->prevVolume[0];
973 int32_t vr = t->prevVolume[1];
974 int32_t va = t->prevAuxLevel;
975 const int32_t vlInc = t->volumeInc[0];
976 const int32_t vrInc = t->volumeInc[1];
977 const int32_t vaInc = t->auxInc;
978
Steve Blockb8a80522011-12-20 16:23:08 +0000979 // ALOGD("[2] %p: inc=%f, v0=%f, v1=%d, final=%f, count=%d",
Mathias Agopian65ab4712010-07-14 17:59:35 -0700980 // t, vlInc/65536.0f, vl/65536.0f, t->volume[0],
981 // (vl + vlInc*frameCount)/65536.0f, frameCount);
982
983 do {
984 int32_t l = *in++;
985 *out++ += (vl >> 16) * l;
986 *out++ += (vr >> 16) * l;
987 *aux++ += (va >> 16) * l;
988 vl += vlInc;
989 vr += vrInc;
990 va += vaInc;
991 } while (--frameCount);
992
993 t->prevVolume[0] = vl;
994 t->prevVolume[1] = vr;
995 t->prevAuxLevel = va;
996 t->adjustVolumeRamp(true);
997 }
998 // constant gain
999 else {
1000 const int16_t vl = t->volume[0];
1001 const int16_t vr = t->volume[1];
1002 const int16_t va = (int16_t)t->auxLevel;
1003 do {
1004 int16_t l = *in++;
1005 out[0] = mulAdd(l, vl, out[0]);
1006 out[1] = mulAdd(l, vr, out[1]);
1007 out += 2;
1008 aux[0] = mulAdd(l, va, aux[0]);
1009 aux++;
1010 } while (--frameCount);
1011 }
1012 } else {
1013 // ramp gain
Glenn Kastenf6b16782011-12-15 09:51:17 -08001014 if (CC_UNLIKELY(t->volumeInc[0]|t->volumeInc[1])) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001015 int32_t vl = t->prevVolume[0];
1016 int32_t vr = t->prevVolume[1];
1017 const int32_t vlInc = t->volumeInc[0];
1018 const int32_t vrInc = t->volumeInc[1];
1019
Steve Blockb8a80522011-12-20 16:23:08 +00001020 // ALOGD("[2] %p: inc=%f, v0=%f, v1=%d, final=%f, count=%d",
Mathias Agopian65ab4712010-07-14 17:59:35 -07001021 // t, vlInc/65536.0f, vl/65536.0f, t->volume[0],
1022 // (vl + vlInc*frameCount)/65536.0f, frameCount);
1023
1024 do {
1025 int32_t l = *in++;
1026 *out++ += (vl >> 16) * l;
1027 *out++ += (vr >> 16) * l;
1028 vl += vlInc;
1029 vr += vrInc;
1030 } while (--frameCount);
1031
1032 t->prevVolume[0] = vl;
1033 t->prevVolume[1] = vr;
1034 t->adjustVolumeRamp(false);
1035 }
1036 // constant gain
1037 else {
1038 const int16_t vl = t->volume[0];
1039 const int16_t vr = t->volume[1];
1040 do {
1041 int16_t l = *in++;
1042 out[0] = mulAdd(l, vl, out[0]);
1043 out[1] = mulAdd(l, vr, out[1]);
1044 out += 2;
1045 } while (--frameCount);
1046 }
1047 }
1048 t->in = in;
1049}
1050
Mathias Agopian65ab4712010-07-14 17:59:35 -07001051// no-op case
John Grossman4ff14ba2012-02-08 16:37:41 -08001052void AudioMixer::process__nop(state_t* state, int64_t pts)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001053{
1054 uint32_t e0 = state->enabledTracks;
1055 size_t bufSize = state->frameCount * sizeof(int16_t) * MAX_NUM_CHANNELS;
1056 while (e0) {
1057 // process by group of tracks with same output buffer to
1058 // avoid multiple memset() on same buffer
1059 uint32_t e1 = e0, e2 = e0;
1060 int i = 31 - __builtin_clz(e1);
1061 track_t& t1 = state->tracks[i];
1062 e2 &= ~(1<<i);
1063 while (e2) {
1064 i = 31 - __builtin_clz(e2);
1065 e2 &= ~(1<<i);
1066 track_t& t2 = state->tracks[i];
Glenn Kastenf6b16782011-12-15 09:51:17 -08001067 if (CC_UNLIKELY(t2.mainBuffer != t1.mainBuffer)) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001068 e1 &= ~(1<<i);
1069 }
1070 }
1071 e0 &= ~(e1);
1072
1073 memset(t1.mainBuffer, 0, bufSize);
1074
1075 while (e1) {
1076 i = 31 - __builtin_clz(e1);
1077 e1 &= ~(1<<i);
1078 t1 = state->tracks[i];
1079 size_t outFrames = state->frameCount;
1080 while (outFrames) {
1081 t1.buffer.frameCount = outFrames;
John Grossman4ff14ba2012-02-08 16:37:41 -08001082 int64_t outputPTS = calculateOutputPTS(
1083 t1, pts, state->frameCount - outFrames);
1084 t1.bufferProvider->getNextBuffer(&t1.buffer, outputPTS);
Glenn Kastena0d68332012-01-27 16:47:15 -08001085 if (t1.buffer.raw == NULL) break;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001086 outFrames -= t1.buffer.frameCount;
1087 t1.bufferProvider->releaseBuffer(&t1.buffer);
1088 }
1089 }
1090 }
1091}
1092
1093// generic code without resampling
John Grossman4ff14ba2012-02-08 16:37:41 -08001094void AudioMixer::process__genericNoResampling(state_t* state, int64_t pts)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001095{
1096 int32_t outTemp[BLOCKSIZE * MAX_NUM_CHANNELS] __attribute__((aligned(32)));
1097
1098 // acquire each track's buffer
1099 uint32_t enabledTracks = state->enabledTracks;
1100 uint32_t e0 = enabledTracks;
1101 while (e0) {
1102 const int i = 31 - __builtin_clz(e0);
1103 e0 &= ~(1<<i);
1104 track_t& t = state->tracks[i];
1105 t.buffer.frameCount = state->frameCount;
John Grossman4ff14ba2012-02-08 16:37:41 -08001106 t.bufferProvider->getNextBuffer(&t.buffer, pts);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001107 t.frameCount = t.buffer.frameCount;
1108 t.in = t.buffer.raw;
1109 // t.in == NULL can happen if the track was flushed just after having
1110 // been enabled for mixing.
1111 if (t.in == NULL)
1112 enabledTracks &= ~(1<<i);
1113 }
1114
1115 e0 = enabledTracks;
1116 while (e0) {
1117 // process by group of tracks with same output buffer to
1118 // optimize cache use
1119 uint32_t e1 = e0, e2 = e0;
1120 int j = 31 - __builtin_clz(e1);
1121 track_t& t1 = state->tracks[j];
1122 e2 &= ~(1<<j);
1123 while (e2) {
1124 j = 31 - __builtin_clz(e2);
1125 e2 &= ~(1<<j);
1126 track_t& t2 = state->tracks[j];
Glenn Kastenf6b16782011-12-15 09:51:17 -08001127 if (CC_UNLIKELY(t2.mainBuffer != t1.mainBuffer)) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001128 e1 &= ~(1<<j);
1129 }
1130 }
1131 e0 &= ~(e1);
1132 // this assumes output 16 bits stereo, no resampling
1133 int32_t *out = t1.mainBuffer;
1134 size_t numFrames = 0;
1135 do {
1136 memset(outTemp, 0, sizeof(outTemp));
1137 e2 = e1;
1138 while (e2) {
1139 const int i = 31 - __builtin_clz(e2);
1140 e2 &= ~(1<<i);
1141 track_t& t = state->tracks[i];
1142 size_t outFrames = BLOCKSIZE;
1143 int32_t *aux = NULL;
Glenn Kastenf6b16782011-12-15 09:51:17 -08001144 if (CC_UNLIKELY((t.needs & NEEDS_AUX__MASK) == NEEDS_AUX_ENABLED)) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001145 aux = t.auxBuffer + numFrames;
1146 }
1147 while (outFrames) {
1148 size_t inFrames = (t.frameCount > outFrames)?outFrames:t.frameCount;
1149 if (inFrames) {
Glenn Kastena1117922012-01-26 10:53:32 -08001150 t.hook(&t, outTemp + (BLOCKSIZE-outFrames)*MAX_NUM_CHANNELS, inFrames, state->resampleTemp, aux);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001151 t.frameCount -= inFrames;
1152 outFrames -= inFrames;
Glenn Kastenf6b16782011-12-15 09:51:17 -08001153 if (CC_UNLIKELY(aux != NULL)) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001154 aux += inFrames;
1155 }
1156 }
1157 if (t.frameCount == 0 && outFrames) {
1158 t.bufferProvider->releaseBuffer(&t.buffer);
1159 t.buffer.frameCount = (state->frameCount - numFrames) - (BLOCKSIZE - outFrames);
John Grossman4ff14ba2012-02-08 16:37:41 -08001160 int64_t outputPTS = calculateOutputPTS(
1161 t, pts, numFrames + (BLOCKSIZE - outFrames));
1162 t.bufferProvider->getNextBuffer(&t.buffer, outputPTS);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001163 t.in = t.buffer.raw;
1164 if (t.in == NULL) {
1165 enabledTracks &= ~(1<<i);
1166 e1 &= ~(1<<i);
1167 break;
1168 }
1169 t.frameCount = t.buffer.frameCount;
1170 }
1171 }
1172 }
1173 ditherAndClamp(out, outTemp, BLOCKSIZE);
1174 out += BLOCKSIZE;
1175 numFrames += BLOCKSIZE;
1176 } while (numFrames < state->frameCount);
1177 }
1178
1179 // release each track's buffer
1180 e0 = enabledTracks;
1181 while (e0) {
1182 const int i = 31 - __builtin_clz(e0);
1183 e0 &= ~(1<<i);
1184 track_t& t = state->tracks[i];
1185 t.bufferProvider->releaseBuffer(&t.buffer);
1186 }
1187}
1188
1189
Glenn Kastenc5ac4cb2011-12-12 09:05:55 -08001190// generic code with resampling
John Grossman4ff14ba2012-02-08 16:37:41 -08001191void AudioMixer::process__genericResampling(state_t* state, int64_t pts)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001192{
Glenn Kasten54c3b662012-01-06 07:46:30 -08001193 // this const just means that local variable outTemp doesn't change
Mathias Agopian65ab4712010-07-14 17:59:35 -07001194 int32_t* const outTemp = state->outputTemp;
1195 const size_t size = sizeof(int32_t) * MAX_NUM_CHANNELS * state->frameCount;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001196
1197 size_t numFrames = state->frameCount;
1198
1199 uint32_t e0 = state->enabledTracks;
1200 while (e0) {
1201 // process by group of tracks with same output buffer
1202 // to optimize cache use
1203 uint32_t e1 = e0, e2 = e0;
1204 int j = 31 - __builtin_clz(e1);
1205 track_t& t1 = state->tracks[j];
1206 e2 &= ~(1<<j);
1207 while (e2) {
1208 j = 31 - __builtin_clz(e2);
1209 e2 &= ~(1<<j);
1210 track_t& t2 = state->tracks[j];
Glenn Kastenf6b16782011-12-15 09:51:17 -08001211 if (CC_UNLIKELY(t2.mainBuffer != t1.mainBuffer)) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001212 e1 &= ~(1<<j);
1213 }
1214 }
1215 e0 &= ~(e1);
1216 int32_t *out = t1.mainBuffer;
Yuuhi Yamaguchi2151d7b2011-02-04 15:24:34 +01001217 memset(outTemp, 0, size);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001218 while (e1) {
1219 const int i = 31 - __builtin_clz(e1);
1220 e1 &= ~(1<<i);
1221 track_t& t = state->tracks[i];
1222 int32_t *aux = NULL;
Glenn Kastenf6b16782011-12-15 09:51:17 -08001223 if (CC_UNLIKELY((t.needs & NEEDS_AUX__MASK) == NEEDS_AUX_ENABLED)) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001224 aux = t.auxBuffer;
1225 }
1226
1227 // this is a little goofy, on the resampling case we don't
1228 // acquire/release the buffers because it's done by
1229 // the resampler.
1230 if ((t.needs & NEEDS_RESAMPLE__MASK) == NEEDS_RESAMPLE_ENABLED) {
John Grossman4ff14ba2012-02-08 16:37:41 -08001231 t.resampler->setPTS(pts);
Glenn Kastena1117922012-01-26 10:53:32 -08001232 t.hook(&t, outTemp, numFrames, state->resampleTemp, aux);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001233 } else {
1234
1235 size_t outFrames = 0;
1236
1237 while (outFrames < numFrames) {
1238 t.buffer.frameCount = numFrames - outFrames;
John Grossman4ff14ba2012-02-08 16:37:41 -08001239 int64_t outputPTS = calculateOutputPTS(t, pts, outFrames);
1240 t.bufferProvider->getNextBuffer(&t.buffer, outputPTS);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001241 t.in = t.buffer.raw;
1242 // t.in == NULL can happen if the track was flushed just after having
1243 // been enabled for mixing.
1244 if (t.in == NULL) break;
1245
Glenn Kastenf6b16782011-12-15 09:51:17 -08001246 if (CC_UNLIKELY(aux != NULL)) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001247 aux += outFrames;
1248 }
Glenn Kastena1117922012-01-26 10:53:32 -08001249 t.hook(&t, outTemp + outFrames*MAX_NUM_CHANNELS, t.buffer.frameCount, state->resampleTemp, aux);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001250 outFrames += t.buffer.frameCount;
1251 t.bufferProvider->releaseBuffer(&t.buffer);
1252 }
1253 }
1254 }
1255 ditherAndClamp(out, outTemp, numFrames);
1256 }
1257}
1258
1259// one track, 16 bits stereo without resampling is the most common case
John Grossman4ff14ba2012-02-08 16:37:41 -08001260void AudioMixer::process__OneTrack16BitsStereoNoResampling(state_t* state,
1261 int64_t pts)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001262{
Glenn Kasten99e53b82012-01-19 08:59:58 -08001263 // This method is only called when state->enabledTracks has exactly
1264 // one bit set. The asserts below would verify this, but are commented out
1265 // since the whole point of this method is to optimize performance.
Glenn Kasten5798d4e2012-03-08 12:18:35 -08001266 //ALOG_ASSERT(0 != state->enabledTracks, "no tracks enabled");
Mathias Agopian65ab4712010-07-14 17:59:35 -07001267 const int i = 31 - __builtin_clz(state->enabledTracks);
Glenn Kasten5798d4e2012-03-08 12:18:35 -08001268 //ALOG_ASSERT((1 << i) == state->enabledTracks, "more than 1 track enabled");
Mathias Agopian65ab4712010-07-14 17:59:35 -07001269 const track_t& t = state->tracks[i];
1270
1271 AudioBufferProvider::Buffer& b(t.buffer);
1272
1273 int32_t* out = t.mainBuffer;
1274 size_t numFrames = state->frameCount;
1275
1276 const int16_t vl = t.volume[0];
1277 const int16_t vr = t.volume[1];
1278 const uint32_t vrl = t.volumeRL;
1279 while (numFrames) {
1280 b.frameCount = numFrames;
John Grossman4ff14ba2012-02-08 16:37:41 -08001281 int64_t outputPTS = calculateOutputPTS(t, pts, out - t.mainBuffer);
1282 t.bufferProvider->getNextBuffer(&b, outputPTS);
Glenn Kasten54c3b662012-01-06 07:46:30 -08001283 const int16_t *in = b.i16;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001284
1285 // in == NULL can happen if the track was flushed just after having
1286 // been enabled for mixing.
1287 if (in == NULL || ((unsigned long)in & 3)) {
1288 memset(out, 0, numFrames*MAX_NUM_CHANNELS*sizeof(int16_t));
Steve Block29357bc2012-01-06 19:20:56 +00001289 ALOGE_IF(((unsigned long)in & 3), "process stereo track: input buffer alignment pb: buffer %p track %d, channels %d, needs %08x",
Mathias Agopian65ab4712010-07-14 17:59:35 -07001290 in, i, t.channelCount, t.needs);
1291 return;
1292 }
1293 size_t outFrames = b.frameCount;
1294
Glenn Kastenf6b16782011-12-15 09:51:17 -08001295 if (CC_UNLIKELY(uint32_t(vl) > UNITY_GAIN || uint32_t(vr) > UNITY_GAIN)) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001296 // volume is boosted, so we might need to clamp even though
1297 // we process only one track.
1298 do {
Glenn Kasten54c3b662012-01-06 07:46:30 -08001299 uint32_t rl = *reinterpret_cast<const uint32_t *>(in);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001300 in += 2;
1301 int32_t l = mulRL(1, rl, vrl) >> 12;
1302 int32_t r = mulRL(0, rl, vrl) >> 12;
1303 // clamping...
1304 l = clamp16(l);
1305 r = clamp16(r);
1306 *out++ = (r<<16) | (l & 0xFFFF);
1307 } while (--outFrames);
1308 } else {
1309 do {
Glenn Kasten54c3b662012-01-06 07:46:30 -08001310 uint32_t rl = *reinterpret_cast<const uint32_t *>(in);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001311 in += 2;
1312 int32_t l = mulRL(1, rl, vrl) >> 12;
1313 int32_t r = mulRL(0, rl, vrl) >> 12;
1314 *out++ = (r<<16) | (l & 0xFFFF);
1315 } while (--outFrames);
1316 }
1317 numFrames -= b.frameCount;
1318 t.bufferProvider->releaseBuffer(&b);
1319 }
1320}
1321
Glenn Kasten81a028f2011-12-15 09:53:12 -08001322#if 0
Mathias Agopian65ab4712010-07-14 17:59:35 -07001323// 2 tracks is also a common case
1324// NEVER used in current implementation of process__validate()
1325// only use if the 2 tracks have the same output buffer
John Grossman4ff14ba2012-02-08 16:37:41 -08001326void AudioMixer::process__TwoTracks16BitsStereoNoResampling(state_t* state,
1327 int64_t pts)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001328{
1329 int i;
1330 uint32_t en = state->enabledTracks;
1331
1332 i = 31 - __builtin_clz(en);
1333 const track_t& t0 = state->tracks[i];
1334 AudioBufferProvider::Buffer& b0(t0.buffer);
1335
1336 en &= ~(1<<i);
1337 i = 31 - __builtin_clz(en);
1338 const track_t& t1 = state->tracks[i];
1339 AudioBufferProvider::Buffer& b1(t1.buffer);
1340
Glenn Kasten54c3b662012-01-06 07:46:30 -08001341 const int16_t *in0;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001342 const int16_t vl0 = t0.volume[0];
1343 const int16_t vr0 = t0.volume[1];
1344 size_t frameCount0 = 0;
1345
Glenn Kasten54c3b662012-01-06 07:46:30 -08001346 const int16_t *in1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001347 const int16_t vl1 = t1.volume[0];
1348 const int16_t vr1 = t1.volume[1];
1349 size_t frameCount1 = 0;
1350
1351 //FIXME: only works if two tracks use same buffer
1352 int32_t* out = t0.mainBuffer;
1353 size_t numFrames = state->frameCount;
Glenn Kasten54c3b662012-01-06 07:46:30 -08001354 const int16_t *buff = NULL;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001355
1356
1357 while (numFrames) {
1358
1359 if (frameCount0 == 0) {
1360 b0.frameCount = numFrames;
John Grossman4ff14ba2012-02-08 16:37:41 -08001361 int64_t outputPTS = calculateOutputPTS(t0, pts,
1362 out - t0.mainBuffer);
1363 t0.bufferProvider->getNextBuffer(&b0, outputPTS);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001364 if (b0.i16 == NULL) {
1365 if (buff == NULL) {
1366 buff = new int16_t[MAX_NUM_CHANNELS * state->frameCount];
1367 }
1368 in0 = buff;
1369 b0.frameCount = numFrames;
1370 } else {
1371 in0 = b0.i16;
1372 }
1373 frameCount0 = b0.frameCount;
1374 }
1375 if (frameCount1 == 0) {
1376 b1.frameCount = numFrames;
John Grossman4ff14ba2012-02-08 16:37:41 -08001377 int64_t outputPTS = calculateOutputPTS(t1, pts,
1378 out - t0.mainBuffer);
1379 t1.bufferProvider->getNextBuffer(&b1, outputPTS);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001380 if (b1.i16 == NULL) {
1381 if (buff == NULL) {
1382 buff = new int16_t[MAX_NUM_CHANNELS * state->frameCount];
1383 }
1384 in1 = buff;
1385 b1.frameCount = numFrames;
Glenn Kastenc5ac4cb2011-12-12 09:05:55 -08001386 } else {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001387 in1 = b1.i16;
1388 }
1389 frameCount1 = b1.frameCount;
1390 }
1391
1392 size_t outFrames = frameCount0 < frameCount1?frameCount0:frameCount1;
1393
1394 numFrames -= outFrames;
1395 frameCount0 -= outFrames;
1396 frameCount1 -= outFrames;
1397
1398 do {
1399 int32_t l0 = *in0++;
1400 int32_t r0 = *in0++;
1401 l0 = mul(l0, vl0);
1402 r0 = mul(r0, vr0);
1403 int32_t l = *in1++;
1404 int32_t r = *in1++;
1405 l = mulAdd(l, vl1, l0) >> 12;
1406 r = mulAdd(r, vr1, r0) >> 12;
1407 // clamping...
1408 l = clamp16(l);
1409 r = clamp16(r);
1410 *out++ = (r<<16) | (l & 0xFFFF);
1411 } while (--outFrames);
1412
1413 if (frameCount0 == 0) {
1414 t0.bufferProvider->releaseBuffer(&b0);
1415 }
1416 if (frameCount1 == 0) {
1417 t1.bufferProvider->releaseBuffer(&b1);
1418 }
1419 }
1420
Glenn Kastene9dd0172012-01-27 18:08:45 -08001421 delete [] buff;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001422}
Glenn Kasten81a028f2011-12-15 09:53:12 -08001423#endif
Mathias Agopian65ab4712010-07-14 17:59:35 -07001424
John Grossman4ff14ba2012-02-08 16:37:41 -08001425int64_t AudioMixer::calculateOutputPTS(const track_t& t, int64_t basePTS,
1426 int outputFrameIndex)
1427{
1428 if (AudioBufferProvider::kInvalidPTS == basePTS)
1429 return AudioBufferProvider::kInvalidPTS;
1430
Glenn Kasten52008f82012-03-18 09:34:41 -07001431 return basePTS + ((outputFrameIndex * sLocalTimeFreq) / t.sampleRate);
1432}
1433
1434/*static*/ uint64_t AudioMixer::sLocalTimeFreq;
1435/*static*/ pthread_once_t AudioMixer::sOnceControl = PTHREAD_ONCE_INIT;
1436
1437/*static*/ void AudioMixer::sInitRoutine()
1438{
1439 LocalClock lc;
1440 sLocalTimeFreq = lc.getLocalFreq();
John Grossman4ff14ba2012-02-08 16:37:41 -08001441}
1442
Mathias Agopian65ab4712010-07-14 17:59:35 -07001443// ----------------------------------------------------------------------------
1444}; // namespace android