115 // allow less retry attempts on direct output thread.
450         audio_io_handle_t output,
471         PlaybackThread *thread = checkPlaybackThread_l(output);
474             ALOGE("unknown output thread");
484             // output thread and move it here.
487                 if (mPlaybackThreads.keyAt(i) != output) {
508         // move effect chain to this output thread if an effect on same session was waiting
547 uint32_t AudioFlinger::sampleRate(audio_io_handle_t output) const
550     PlaybackThread *thread = checkPlaybackThread_l(output);
552         ALOGW("sampleRate() unknown thread %d", output);
558 int AudioFlinger::channelCount(audio_io_handle_t output) const
561     PlaybackThread *thread = checkPlaybackThread_l(output);
563         ALOGW("channelCount() unknown thread %d", output);
569 audio_format_t AudioFlinger::format(audio_io_handle_t output) const
572     PlaybackThread *thread = checkPlaybackThread_l(output);
574         ALOGW("format() unknown thread %d", output);
580 size_t AudioFlinger::frameCount(audio_io_handle_t output) const
583     PlaybackThread *thread = checkPlaybackThread_l(output);
585         ALOGW("frameCount() unknown thread %d", output);
593 uint32_t AudioFlinger::latency(audio_io_handle_t output) const
596     PlaybackThread *thread = checkPlaybackThread_l(output);
598         ALOGW("latency() unknown thread %d", output);
771         audio_io_handle_t output)
785     if (output) {
786         thread = checkPlaybackThread_l(output);
826 float AudioFlinger::streamVolume(audio_stream_type_t stream, audio_io_handle_t output) const
834     if (output) {
835         PlaybackThread *thread = checkPlaybackThread_l(output);
925             // indicate output device change to all input threads for pre processing
1032         audio_io_handle_t output) const
1038     PlaybackThread *playbackThread = checkPlaybackThread_l(output);
1544                                              AudioStreamOut* output,
1551         mOutput(output),
1758             // FIXME test that MixerThread for this fast track has a capable output HAL
1795                         "for output %p with format %d",
1802         // Resampler implementation limits input sampling rate to 2 x output sampling rate.
1820         // conflicts will happen when tracks are moved from one output to another by audio policy
2059         ALOGW("HAL output buffer size is %u frames but AudioMixer requires multiples of 16 frames",
2063     // Calculate size of normal mix buffer relative to the HAL output buffer size
2100     ALOGI("HAL output buffer size %u frames, normal mix buffer size %u frames", mFrameCount, mNormalFrameCount);
2131         // return an estimation of rendered frames when the output is suspended
2166     // it is moved to correct output by audio policy manager when A2DP is connected or disconnected
2190     AudioStreamOut *output = mOutput;
2197     return output;
2255 AudioFlinger::MixerThread::MixerThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
2257     :   PlaybackThread(audioFlinger, output, id, device, type),
2272     // FIXME - Current mixer implementation only supports stereo output
2277     // create an NBAIO sink for the HAL output stream, and negotiate
2278     mOutputSink = new AudioStreamOutSink(output->stream);
2315         // create a Pipe to archive a copy of FastMixer's output for dumpsys
2343         // fast mixer will use the HAL output sink
2710         // put output stream into standby mode
2796         // Direct output thread.
2843     // obtain the presentation timestamp of the next output buffer
2873     // If no tracks are ready, sleep once for the duration of an output
2874     // buffer size, then write 0s to the output
2919     // Delegate master volume control to effect in output mix effect chain if needed
3502             // when changing the audio output device, call addBatteryData to notify
3552                     // limit track sample rate to 2 x new output sample rate
3607     // Write the tee output to a .wav file
3696         AudioStreamOut* output, audio_io_handle_t id, audio_devices_t device)
3697     :   PlaybackThread(audioFlinger, output, id, device, DIRECT)
3846     // output audio to hardware
3976     // use shorter standby delay as on normal output to release
4024             // flush remaining overflow buffers in output tracks
4111             ALOGW("DuplicatingThread::outputsReady() could not promote thread on output track %p", outputTracks[i].get());
4117             ALOGV("DuplicatingThread output track %p on thread %p Not Ready", outputTracks[i].get(), thread.get());
5166         // queue and the start of the next output buffer that will be written.
5168         // that the sample's position in the output stream is so far out of
5192         // the current output position is within this threshold, then we will
5193         // concatenate the next input samples to the previous output
5204             // with the last output
5212         // Looks like our output is not on time.  Reset our on timed status.
5217             // the gap between the current output position and the proper start of
5250 // Yield samples from the timed buffer queue head up to the given output
5271 // Yield samples of silence up to the given output buffer's capacity
5512         ALOGW("Error creating output track on thread %p", playbackThread);
5590                 ALOGV ("OutputTrack::write() %p thread %p no more output buffers", this, mThread.unsafe_get());
5641     // If no more buffers are pending, fill output track buffer to make sure it is started
5642     // by output mixer.
6155                     // alter output frame count as if we were expecting stereo samples
6630             // store input device and output device but do not forward output device to audio HAL.
6631             // Note that status is ignored by the caller for output device
6992     ALOGV("openOutput() openOutputStream returned output %p, SamplingRate %d, Format %d, Channels %x, status %d",
7000         AudioStreamOut *output = new AudioStreamOut(outHwDev, outStream);
7005             thread = new DirectOutputThread(this, output, id, *pDevices);
7006             ALOGV("openOutput() created direct output: ID %d thread %p", id, thread);
7008             thread = new MixerThread(this, output, id, *pDevices);
7009             ALOGV("openOutput() created mixer output: ID %d thread %p", id, thread);
7018         // notify client processes of the new output creation
7021         // the first primary output opened designates the primary hw device
7045         ALOGW("openDuplicateOutput() wrong output mixer type for output %d or %d", output1, output2);
7053     // notify client processes of the new output creation
7058 status_t AudioFlinger::closeOutput(audio_io_handle_t output)
7060     return closeOutput_nonvirtual(output);
7063 status_t AudioFlinger::closeOutput_nonvirtual(audio_io_handle_t output)
7070         thread = checkPlaybackThread_l(output);
7075         ALOGV("closeOutput() %d", output);
7085         audioConfigChanged_l(AudioSystem::OUTPUT_CLOSED, output, NULL);
7086         mPlaybackThreads.removeItem(output);
7102 status_t AudioFlinger::suspendOutput(audio_io_handle_t output)
7105     PlaybackThread *thread = checkPlaybackThread_l(output);
7111     ALOGV("suspendOutput() %d", output);
7117 status_t AudioFlinger::restoreOutput(audio_io_handle_t output)
7120     PlaybackThread *thread = checkPlaybackThread_l(output);
7126     ALOGV("restoreOutput() %d", output);
7190         // RecorThread require both input and output device indication to forward to audio
7247 status_t AudioFlinger::setStreamOutput(audio_stream_type_t stream, audio_io_handle_t output)
7250     ALOGV("setStreamOutput() stream %d to output %d", stream, output);
7365 AudioFlinger::PlaybackThread *AudioFlinger::checkPlaybackThread_l(audio_io_handle_t output) const
7367     return mPlaybackThreads.valueFor(output).get();
7371 AudioFlinger::MixerThread *AudioFlinger::checkMixerThread_l(audio_io_handle_t output) const
7373     PlaybackThread *thread = checkPlaybackThread_l(output);
7392         AudioStreamOut *output = thread->getOutput();
7393         if (output != NULL && output->audioHwDev == mPrimaryHardwareDev) {
7496     // Session AUDIO_SESSION_OUTPUT_STAGE is reserved for output stage effects
7505             // output must be specified by AudioPolicyManager when using session
7510             // if the output returned by getOutputForEffect() is removed before we lock the
7570             // connect to output mix (Compliance to OpenSL ES)
7577         // Do not allow auxiliary effects on a session different from 0 (output mix)
7594         // If output is not specified try to find a matching audio session ID in one of the
7595         // output threads.
7596         // If output is 0 here, sessionId is neither SESSION_OUTPUT_STAGE nor SESSION_OUTPUT_MIX
7597         // because of code checking output when entering the function.
7615             // If no output thread contains the requested session ID, default to
7616             // first output. The effect chain will be moved to the correct output
7627                 ALOGE("createEffect() unknown output thread");
7635         // create effect on selected output thread
7694     // remove chain first. This is useful only if reconfiguring effect chain on same output thread,
7715         // re-registered with the new strategy and output
7765     // Do not allow effects with session ID 0 on direct output or duplicating threads
7992         // Only one effect chain can be present in direct output thread and it uses
8026     // chains list in order to be processed last as it contains output stage effects
8029     // after track specific effects and before output stage
8033     // chains list to be processed before output mix effects. Relative order between other
8380         // If an insert effect is idle and input buffer is different from output buffer,
8381         // accumulate input onto output
8435     // always overwrites output buffer: input buffer == output buffer
8437     //      last effect in the chain accumulates in output buffer: input buffer != output buffer
8438     //      other effect: overwrites output buffer: input buffer == output buffer
8440     //      accumulates in output buffer: input buffer != output buffer
8441     // Therefore: accumulate <=> input buffer != output buffer
9334         // auxiliary effects output samples to chain input buffer for further processing
9402         // if last effect in the chain, output samples to chain
9403         // output buffer, otherwise to chain input buffer
9686     // auxiliary effects and visualizer are never suspended on output mix

Indexes created Thu Nov 22 16:40:23 CET 2012