Android 7.0 Audio Framework详解：框架、服务与流程

需积分: 0 32 浏览量更新于2024-07-15 收藏 2.29MB PDF 举报

"Android7.0 Audio Framework主要涵盖了声音播放和录音功能，重点在于理解Framework层的工作原理和架构。本文档将深入探讨Audio框架的组成部分，包括JAVA程序、JNI调用、客户端和服务端的实现，以及关键服务如AudioFlinger的创建和作用。" Android的Audio子系统是操作系统中的一个重要组成部分，它确保了音频数据的有效处理，无论是播放还是录制。在Android 7.0中，Audio框架主要由以下几个关键部分组成： 1. **Audio的JAVA程序**：音乐播放器位于`leadcore/third-packages/apps/Music/src/com/android/music`，而录音功能则在`packages/apps/SoundRecorder/src/com/android/soundrecorder`。这些应用程序使用Android提供的API来与Audio框架交互。 2. **JAVA本地调用（JNI）**：JNI接口在`frameworks/base/core/jni`目录下，如`android_media_AudioTrack.cpp`, `android_media_AudioRecord.cpp`和`android_media_AudioSystem.cpp`。这些文件实现了JAVA层与C/C++层的交互，使得可以直接操作底层硬件。 3. **Audio的客户端**：客户端接口定义在`frameworks/av/include/media/`，对应的实现位于`frameworks/av/media/libmedia`。这部分代码编译成`libmedia.so`库，供上层应用程序和系统服务使用。 4. **Audio的服务部分**：包括`frameworks/av/services/audioflinger/`中的AudioFlinger服务，以及`frameworks/av/services/audiopolicy/`下的音频策略服务。AudioFlinger服务是音频处理的核心，它负责混合音频流并管理硬件资源。音频策略服务则决定了不同音频流的优先级和混合策略。 **AudioFlinger服务**是Android音频系统的关键组件，它继承自Binder类，能够实现跨进程通信。AudioFlinger不仅管理着多个音频会话，还负责音频流的混音、路由和硬件访问。它通过Binder机制与其他进程（如应用程序或系统服务）通信，提供音频服务。 **Audio Policy Manager**是另一个核心组件，它根据系统状态和用户需求制定音频策略。例如，当电话铃声响起时，它会自动调整媒体音量和当前正在播放的音乐音量，以确保正确的声音输出。 **服务创建过程**：AudioFlinger作为Binder服务，通过系统服务注册并在系统启动时自动启动。它创建音频硬件接口实例，并管理所有与音频硬件交互的线程和缓冲区。AudioPolicyManager则根据配置文件和运行时条件动态调整音频策略。 Android 7.0的Audio Framework是一个复杂但有序的系统，它通过精心设计的组件和服务协同工作，提供了高效、灵活的音频处理能力。开发者可以利用这些组件构建各种音频应用，同时享受到Android系统对音频处理的全面支持。

case 0:

return true;

case NS_INACTIVE:

pauseInternal();

return true;

case NS_NEVER:

return false;

case NS_WHENEVER:

// Event driven: call wake() when callback notifications conditions change.

ns = INT64_MAX;

// fall through

default:

LOG_ALWAYS_FATAL_IF(ns < 0, "processAudioBuffer() returned %" PRId64, ns);

pauseInternal(ns);

return true;

}

当 AudioTrackThread 创建时，由于 mPaused := true ，所以这个线程就会一直等待直到 AudioTrack::start()

来启动它。

接下来就是通过一系列的调用，建立AudioTrack以及AudioFlinger两端的Track，以及环形缓冲区等：

status_t AudioTrack::createTrack_l()

{

// create connection between AudioSystem and AudioFlinger, and return an

IAudioFlinger;

 const sp<IAudioFlinger>& audioFlinger = AudioSystem::get_audio_flinger();

...

 audio_io_handle_t output;

 audio_stream_type_t streamType = mStreamType;

 audio_attributes_t *attr = (mStreamType == AUDIO_STREAM_DEFAULT) ? &mAttributes :

NULL;

 status_t status;

// create connection between AudioSystem and AudioPolicyService;

// with parameters as follow: attr := paa (not NULL), streamType :=

AUDIO_STREAM_DEFAULT,

// mSelectedDeviceId := AUDIO_PORT_HANDLE_NONE

// calls AudioPolicyManager to get the output handle for such stream attributes,

 status = AudioSystem::getOutputForAttr(attr, &output,

                     (audio_session_t)mSessionId, &streamType,

mClientUid,

                     mSampleRate, mFormat, mChannelMask,

                     mFlags, mSelectedDeviceId, mOffloadInfo);

...

 {

 // Now that we have a reference to an I/O handle and have not yet handed it off to

AudioFlinger,

 // we must release it ourselves if anything goes wrong.

 // Not all of these values are needed under all conditions, but it is easier to get

them all

 status = AudioSystem::getLatency(output, &mAfLatency);

 status = AudioSystem::getFrameCount(output, &mAfFrameCount);

 status = AudioSystem::getSamplingRate(output, &mAfSampleRate);

 if (mSampleRate == 0) {

   mSampleRate = mAfSampleRate;

   mOriginalSampleRate = mAfSampleRate;

 }

...

 // The client's AudioTrack buffer is divided into n parts for purpose of wakeup by

server, where

 // n = 1  fast track with single buffering; nBuffering is ignored

 // n = 2  fast track with double buffering

 // n = 2  normal track, (including those with sample rate conversion)

 // n >= 3 very high latency or very small notification interval (unused).

 const uint32_t nBuffering = 2;

// mNotificationFramesReq := 0

 mNotificationFramesAct = mNotificationFramesReq;

 //=======Compute frameCount with mAfxxxx =======

 size_t frameCount = mReqFrameCount;

 if (!audio_is_linear_pcm(mFormat)) {

...

 } else {

   // For fast tracks the frame count calculations and checks are done by server

   if ((mFlags & AUDIO_OUTPUT_FLAG_FAST) == 0) {

     // for normal tracks precompute the frame count based on speed.

     const size_t minFrameCount = calculateMinFrameCount(

         mAfLatency, mAfFrameCount, mAfSampleRate, mSampleRate,

         mPlaybackRate.mSpeed);

     if (frameCount < minFrameCount || mOriginType != streamType) {

       frameCount = minFrameCount;

     }

   }

 }

 //=======Compute frameCount END =======

// something about flags

...

 size_t temp = frameCount;  // temp may be replaced by a revised value of frameCount,

               // but we will still need the original value also

 int originalSessionId = mSessionId;

 sp<IAudioTrack> track = audioFlinger->createTrack(streamType,

                          mSampleRate,

                          mFormat,

                          mChannelMask,

                          &temp,

                          &trackFlags,

                          mSharedBuffer,

                          output,

                          tid,

                          &mSessionId,

                          mClientUid,

                          &status);

...

 // after AudioFlinger create track

}



// @AudioFlinger

// streamType := AUDIO_STREAM_MUSIC, sharedBuffer := NULL

sp<IAudioTrack> AudioFlinger::createTrack(

   audio_stream_type_t streamType,

   uint32_t sampleRate,

   audio_format_t format,

   audio_channel_mask_t channelMask,

   size_t *frameCount,

   IAudioFlinger::track_flags_t *flags,

   const sp<IMemory>& sharedBuffer,

   audio_io_handle_t output,

   pid_t tid,

   int *sessionId,

   int clientUid,

   status_t *status)

{

 sp<PlaybackThread::Track> track;

 sp<TrackHandle> trackHandle;

 sp<Client> client;

 status_t lStatus;

 int lSessionId;

// some further checkings;

...

 {

   Mutex::Autolock _l(mLock);

  // get the corresponding PlaybackThreads for the given output;

   PlaybackThread *thread = checkPlaybackThread_l(output);

...

   pid_t pid = IPCThreadState::self()->getCallingPid();

  // new a Client with the given pid, which would then allocate memory

  // detail investigation will be given later

   client = registerPid(pid);

...

   track = thread->createTrack_l(client, streamType, sampleRate, format,

       channelMask, frameCount, sharedBuffer, lSessionId, flags, tid, clientUid,

&lStatus);

   LOG_ALWAYS_FATAL_IF((lStatus == NO_ERROR) && (track == 0));

   // we don't abort yet if lStatus != NO_ERROR; there is still work to be done

regardless

   // move effect chain to this output thread if an effect on same session was

waiting

   // for a track to be created

   if (lStatus == NO_ERROR && effectThread != NULL) {

     // no risk of deadlock because AudioFlinger::mLock is held

     Mutex::Autolock _dl(thread->mLock);

     Mutex::Autolock _sl(effectThread->mLock);

     moveEffectChain_l(lSessionId, effectThread, thread, true);

   }

   // Look for sync events awaiting for a session to be used.

  // add to mSyncEvents;

   for (size_t i = 0; i < mPendingSyncEvents.size(); i++) {

     if (mPendingSyncEvents[i]->triggerSession() == lSessionId) {

       if (thread->isValidSyncEvent(mPendingSyncEvents[i])) {

         if (lStatus == NO_ERROR) {

           (void) track->setSyncEvent(mPendingSyncEvents[i]);

         } else {

           mPendingSyncEvents[i]->cancel();

         }

         mPendingSyncEvents.removeAt(i);

         i--;

       }

     }

   }

// intend to set HW synchronization source for an output stream, but in lte20007,

  // no support for this in the HAL module

   setAudioHwSyncForSession_l(thread, (audio_session_t)lSessionId);

 }

 if (lStatus != NO_ERROR) {

   // remove local strong reference to Client before deleting the Track so that the

   // Client destructor is called by the TrackBase destructor with mClientLock held

   // Don't hold mClientLock when releasing the reference on the track as the

   // destructor will acquire it.

   {

     Mutex::Autolock _cl(mClientLock);

     client.clear();

   }

   track.clear();

   goto Exit;

 }

 // return handle to client

 trackHandle = new TrackHandle(track);

Exit:

 *status = lStatus;

 return trackHandle;

}

// @AudioFlinger::PlaybackThread

sp<AudioFlinger::PlaybackThread::Track> AudioFlinger::PlaybackThread::createTrack_l(

   const sp<AudioFlinger::Client>& client,

   audio_stream_type_t streamType,

   uint32_t sampleRate,

   audio_format_t format,

   audio_channel_mask_t channelMask,

   size_t *pFrameCount,

   const sp<IMemory>& sharedBuffer,

   int sessionId,

   IAudioFlinger::track_flags_t *flags,

   pid_t tid,

   int uid,

   status_t *status)

{

 size_t frameCount = *pFrameCount;

 sp<Track> track;

 status_t lStatus;

// for FAST TRACK flags

...

 // calculate frame count

...

// check format according to different types of PlaybackThreads

...

 lStatus = initCheck();

 if (lStatus != NO_ERROR) {

   ALOGE("createTrack_l() audio driver not initialized");

   goto Exit;

 }

 { // scope for mLock

   Mutex::Autolock _l(mLock);

   // all tracks in same audio session must share the same routing strategy

otherwise

   // conflicts will happen when tracks are moved from one output to another by

audio policy

   // manager

...

   if (!isTimed) {

    // new a Track, not TimedTrack here

     track = new Track(this, client, streamType, sampleRate, format,

              channelMask, frameCount, NULL, sharedBuffer,

              sessionId, uid, *flags, TrackBase::TYPE_DEFAULT);

   } else {

     track = TimedTrack::create(this, client, streamType, sampleRate, format,

         channelMask, frameCount, sharedBuffer, sessionId, uid);

   }

   // new Track always returns non-NULL,

   // but TimedTrack::create() is a factory that could fail by returning NULL

   lStatus = track != 0 ? track->initCheck() : (status_t) NO_MEMORY;

   if (lStatus != NO_ERROR) {

     ALOGE("createTrack_l() initCheck failed %d; no control block?", lStatus);

     // track must be cleared from the caller as the caller has the AF lock

     goto Exit;

   }

   mTracks.add(track);

剩余119页未读，继续阅读

xuyin1204

粉丝: 65

Android 7.0 Audio Framework详解：框架、服务与流程

"英语在编程中的重要性及常用词汇-JAVA语言.pdf

《大学英语新版听说教程1答案及交流技巧详解》

JavaScript this关键字详解：规则与应用场景

wenstorm 快捷键（java）（csdn）————程序.pdf

程序设计电子稿———医院候诊系统.pdf

Introduce.OSGi

team introduce.key

Contrologix introduce.rar

CCNA Introduce.ppt

ERP introduce.pptx

最新资源