AudioTrack Start 执行流程分析

dalancon2026-04-27 11:21

AudioTrack Start 执行流程分析

1. 概述

本文档分析 Android 14 (AOSP 14.0.0_r21) 中 AudioTrack.start() 方法的完整执行流程，从 Java 层通过 JNI 调用，经过 Native AudioTrack、Binder IPC 通信，最终到达 AudioFlinger 服务，并详细分析 PlaybackThread 的处理流程。

2. JNI 层流程

文件位置

frameworks/base/core/jni/android_media_AudioTrack.cpp

关键代码 (line 521-531)

cpp 复制代码 
static void
android_media_AudioTrack_start(JNIEnv *env, jobject thiz)
{
    sp<AudioTrack> lpTrack = getAudioTrack(env, thiz);
    if (lpTrack == NULL) {
        jniThrowException(env, "java/lang/IllegalStateException",
            "Unable to retrieve AudioTrack pointer for start()");
        return;
    }

    lpTrack->start();
}

流程说明

  1. 通过 getAudioTrack() 从 Java 对象中获取 Native AudioTrack 对象指针
  2. 检查指针有效性，无效则抛出 IllegalStateException
  3. 调用 Native AudioTrack 的 start() 方法

JNI 注册 (line 1453)

cpp 复制代码 
{"native_start", "()V", (void *)android_media_AudioTrack_start},

Java 层的 AudioTrack.start() 会调用 native 方法 native_start()，映射到此 JNI 函数。

3. Native AudioTrack 层流程

文件位置

frameworks/av/media/libaudioclient/AudioTrack.cpp

AudioTrack::start() 方法 (line 782-920)

cpp 复制代码 
status_t AudioTrack::start()
{
    AutoMutex lock(mLock);

    if (mState == STATE_ACTIVE) {
        return INVALID_OPERATION;
    }

    // 状态管理
    State previousState = mState;
    if (previousState == STATE_PAUSED_STOPPING) {
        mState = STATE_STOPPING;
    } else {
        mState = STATE_ACTIVE;
    }

    // 初始化位置和时间戳
    (void) updateAndGetPosition_l();
    mStartNs = systemTime();

    // 关键调用: 通过 IAudioTrack binder 接口调用 AudioFlinger
    if (!(flags & CBLK_INVALID)) {
        mAudioTrack->start(&status);  // <-- Binder IPC 调用
        if (status == DEAD_OBJECT) {
            flags |= CBLK_INVALID;
        }
    }

    // 处理 AudioTrackThread 回调线程
    sp<AudioTrackThread> t = mAudioTrackThread;
    if (status == NO_ERROR) {
        if (t != 0) {
            if (previousState == STATE_STOPPING) {
                mProxy->interrupt();
            } else {
                t->resume();
            }
        } else {
            androidSetThreadPriority(0, ANDROID_PRIORITY_AUDIO);
        }
        mVolumeHandler->setStarted();
    }

    return status;
}

mAudioTrack (IAudioTrack) 的创建

在 AudioTrack::createTrack_l() 方法 (line 1807-1919) 中创建：

cpp 复制代码 
status_t AudioTrack::createTrack_l()
{
    // 获取 AudioFlinger 服务
    const sp<IAudioFlinger>& audioFlinger = AudioSystem::get_audio_flinger();
    if (audioFlinger == 0) {
        status = DEAD_OBJECT;
        goto exit;
    }

    // 构建输入参数
    IAudioFlinger::CreateTrackInput input;
    input.attr = mAttributes;
    input.config.sample_rate = mSampleRate;
    input.config.channel_mask = mChannelMask;
    input.config.format = mFormat;
    // ... 其他参数设置

    // 调用 AudioFlinger 创建 Track
    media::CreateTrackResponse response;
    status = audioFlinger->createTrack(VALUE_OR_FATAL(input.toAidl()), response);

    // 获取返回的 IAudioTrack 接口
    if (status == NO_ERROR) {
        output = VALUE_OR_FATAL(IAudioFlinger::CreateTrackOutput::fromAidl(response));
    }

    // mAudioTrack 是从 AudioFlinger 返回的 IAudioTrack binder 接口
    mAudioTrack = output.audioTrack;  // <-- IAudioTrack 接口

    return status;
}

4. Binder IPC 通信

IAudioTrack 接口定义

文件: frameworks/av/media/libaudioclient/aidl/android/media/IAudioTrack.aidl

aidl 复制代码 
interface IAudioTrack {
    /** Get this track's control block */
    @nullable SharedFileRegion getCblk();

    /**
     * After it's created the track is not active. Call start() to
     * make it active.
     */
    int start();

    void stop();
    void flush();
    void pause();
    // ... 其他方法
}

Binder 调用流程

scss 复制代码 
┌─────────────────┐                    ┌─────────────────────┐
│   AudioTrack    │                    │    AudioFlinger     │
│   (Client)      │                    │    (Server)         │
├─────────────────┤                    ├─────────────────────┤
│ IAudioTrack     │ ─── Binder IPC ──► │ TrackHandle         │
│ (BpAudioTrack)  │    start()         │ (BnAudioTrack)      │
│                 │                    │                     │
│ mAudioTrack     │                    │ mTrack (Track*)     │
│ ->start()       │                    │ ->start()           │
└─────────────────┘                    └─────────────────────┘

5. AudioFlinger Track 创建

文件位置

frameworks/av/services/audioflinger/AudioFlinger.cpp

AudioFlinger::createTrack() 方法 (line 1105-1310)

cpp 复制代码 
status_t AudioFlinger::createTrack(const media::CreateTrackRequest& _input,
                                   media::CreateTrackResponse& _output)
{
    CreateTrackInput input = VALUE_OR_RETURN_STATUS(CreateTrackInput::fromAidl(_input));
    CreateTrackOutput output;

    sp<PlaybackThread::Track> track;
    sp<TrackHandle> trackHandle;

    // 获取音频输出
    lStatus = AudioSystem::getOutputForAttr(&localAttr, &output.outputId, sessionId,
                                            &streamType, adjAttributionSource,
                                            &input.config, input.flags,
                                            &output.selectedDeviceId, &portId,
                                            &secondaryOutputs, &isSpatialized, &isBitPerfect);

    {
        Mutex::Autolock _l(mLock);
        // 获取对应的 PlaybackThread
        PlaybackThread *thread = checkPlaybackThread_l(output.outputId);
        if (thread == NULL) {
            lStatus = BAD_VALUE;
            goto Exit;
        }

        // 注册客户端
        client = registerPid(clientPid);

        // 在 PlaybackThread 中创建 Track
        track = thread->createTrack_l(client, streamType, localAttr,
                                      &output.sampleRate, input.config.format,
                                      input.config.channel_mask, &output.frameCount,
                                      &output.notificationFrameCount,
                                      input.notificationsPerBuffer, input.speed,
                                      input.sharedBuffer, sessionId, &output.flags,
                                      callingPid, adjAttributionSource,
                                      input.clientInfo.clientTid, &lStatus, portId,
                                      input.audioTrackCallback, isSpatialized, isBitPerfect);

        // 返回 AudioFlinger 相关参数
        output.afFrameCount = thread->frameCount();
        output.afSampleRate = thread->sampleRate();
        output.afChannelMask = thread->channelMask();
        output.afFormat = thread->format();
        output.afLatencyMs = thread->latency();
    }

    // 创建 TrackHandle 作为 IAudioTrack 的服务端实现
    output.audioTrack = new TrackHandle(track);  // <-- 关键: 创建 Binder 服务端

    return lStatus;
}

6. TrackHandle 和 Track::start

TrackHandle 实现

文件: frameworks/av/services/audioflinger/Tracks.cpp (line 334-358)

cpp 复制代码 
AudioFlinger::TrackHandle::TrackHandle(const sp<AudioFlinger::PlaybackThread::Track>& track)
    : BnAudioTrack(),
      mTrack(track)
{
    setMinSchedulerPolicy(SCHED_NORMAL, ANDROID_PRIORITY_AUDIO);
}

Status AudioFlinger::TrackHandle::start(int32_t* _aidl_return) {
    *_aidl_return = mTrack->start();  // <-- 调用 Track::start()
    return Status::ok();
}

Status AudioFlinger::TrackHandle::stop() {
    mTrack->stop();
    return Status::ok();
}

Status AudioFlinger::TrackHandle::flush() {
    mTrack->flush();
    return Status::ok();
}

Status AudioFlinger::TrackHandle::pause() {
    mTrack->pause();
    return Status::ok();
}

Track::start() 实现

文件: frameworks/av/services/audioflinger/Tracks.cpp (line 1062-1198)

cpp 复制代码 
status_t AudioFlinger::PlaybackThread::Track::start(
        AudioSystem::sync_event_t event __unused,
        audio_session_t triggerSession __unused)
{
    status_t status = NO_ERROR;

    sp<ThreadBase> thread = mThread.promote();
    if (thread != 0) {
        Mutex::Autolock _lth(thread->mLock);
        track_state state = mState;

        // 处理 Flush 状态
        if (state == FLUSHED) {
            reset();  // 重置 Track 状态
        }

        mPauseHwPending = false;

        // 状态转换
        if (state == PAUSED || state == PAUSING) {
            if (mResumeToStopping) {
                mState = TrackBase::STOPPING_1;
            } else {
                mState = TrackBase::RESUMING;  // 从暂停恢复
            }
        } else {
            mState = TrackBase::ACTIVE;  // 设置为活跃状态
        }

        PlaybackThread *playbackThread = (PlaybackThread *)thread.get();

        // 重置 PCM Track 的位置信息
        if (audio_is_linear_pcm(mFormat)
                && (state == IDLE || state == STOPPED || state == FLUSHED)) {
            mFrameMap.reset();
            // 初始化帧映射
            if (!isFastTrack() && (isDirect() || isOffloaded())) {
                mFrameMap.push(mAudioTrackServerProxy->framesReleased(),
                               playbackThread->framesWritten());
            }
        }

        // 关键调用: 将 Track 添加到 PlaybackThread 的活跃列表
        status = playbackThread->addTrack_l(this);  // <-- 核心

        if (status == NO_ERROR || status == ALREADY_EXISTS) {
            mAudioTrackServerProxy->start();  // 启动 Server 端代理
        }

        // 处理已存在的 Track
        if (status == ALREADY_EXISTS) {
            status = NO_ERROR;
        } else {
            // 确认 flush 操作
            ServerProxy::Buffer buffer;
            buffer.mFrameCount = 1;
            (void) mAudioTrackServerProxy->obtainBuffer(&buffer, true /*ackFlush*/);
        }
    } else {
        status = BAD_VALUE;
    }

    return status;
}

7. PlaybackThread 线程循环

addTrack_l() - 添加 Track 到活跃列表

文件: frameworks/av/services/audioflinger/Threads.cpp (line 2774-2878)

cpp 复制代码 
status_t AudioFlinger::PlaybackThread::addTrack_l(const sp<Track>& track)
{
    status_t status = ALREADY_EXISTS;

    if (mActiveTracks.indexOf(track) < 0) {
        // 新 Track, 确保填充缓冲区
        if (track->isExternalTrack()) {
            TrackBase::track_state state = track->mState;
            mLock.unlock();
            // 通知 AudioPolicy 启动输出
            status = AudioSystem::startOutput(track->portId());
            mLock.lock();

            if (status != NO_ERROR) {
                return status == DEAD_OBJECT ? status : PERMISSION_DENIED;
            }

            sendIoConfigEvent_l(AUDIO_CLIENT_STARTED, track->creatorPid(), track->portId());
        }

        // 设置重试计数
        if (track->isOffloaded()) {
            track->mRetryCount = kMaxTrackStartupRetriesOffload;
            track->mFillingUpStatus = mStandby ? Track::FS_FILLING : Track::FS_FILLED;
        } else {
            track->mRetryCount = kMaxTrackStartupRetries;
            track->mFillingUpStatus =
                    track->sharedBuffer() != 0 ? Track::FS_FILLED : Track::FS_FILLING;
        }

        track->mResetDone = false;
        track->resetPresentationComplete();

        // 关键: 将 Track 添加到活跃列表
        mActiveTracks.add(track);  // <-- 核心

        // 处理 Effect Chain
        sp<EffectChain> chain = getEffectChain_l(track->sessionId());
        if (chain != 0) {
            chain->incActiveTrackCnt();
        }

        track->logBeginInterval(patchSinksToString(&mPatch));
        status = NO_ERROR;
    }

    // 唤醒 PlaybackThread
    onAddNewTrack_l();  // <-- 唤醒线程循环

    return status;
}

threadLoop() - 主循环

文件: frameworks/av/services/audioflinger/Threads.cpp (line 3831-4092)

cpp 复制代码 
bool AudioFlinger::PlaybackThread::threadLoop()
{
    Vector< sp<Track> > tracksToRemove;

    mStandbyTimeNs = systemTime();
    cacheParameters_l();
    mSleepTimeUs = mIdleSleepTimeUs;

    acquireWakeLock();

    // 主循环
    for (int64_t loopCount = 0; !exitPending(); ++loopCount)
    {
        Vector< sp<EffectChain> > effectChains;
        std::vector<sp<Track>> activeTracks;

        { // mLock scope
            Mutex::Autolock _l(mLock);

            processConfigEvents_l();
            collectTimestamps_l();
            saveOutputTracks();

            // 检查是否需要进入 standby
            if ((mActiveTracks.isEmpty() && systemTime() > mStandbyTimeNs)
                                   || isSuspended()) {
                if (shouldStandby_l()) {
                    threadLoop_standby();
                    if (!mStandby) {
                        setStandby_l();
                    }
                }

                if (mActiveTracks.isEmpty() && mConfigEvents.isEmpty()) {
                    // 等待新 Track 或事件
                    releaseWakeLock_l();
                    mWaitWorkCV.wait(mLock);  // <-- 等待唤醒
                    acquireWakeLock_l();
                    continue;
                }
            }

            // 关键: 准备活跃 Tracks
            mMixerStatus = prepareTracks_l(&tracksToRemove);  // <-- 核心

            mActiveTracks.updatePowerState(this);

            // 获取活跃 Track 列表
            activeTracks.insert(activeTracks.end(),
                               mActiveTracks.begin(), mActiveTracks.end());

        } // mLock scope ends

        // 混音和写入
        if (mBytesRemaining == 0) {
            mCurrentWriteLength = 0;
            if (mMixerStatus == MIXER_TRACKS_READY) {
                // 关键: 混音
                threadLoop_mix();  // <-- 核心
            } else if ((mMixerStatus != MIXER_DRAIN_TRACK)
                        && (mMixerStatus != MIXER_DRAIN_ALL)) {
                threadLoop_sleepTime();
                if (mSleepTimeUs == 0) {
                    mCurrentWriteLength = mSinkBufferSize;
                }
            }

            // 数据拷贝到 sink buffer
            if (mMixerBufferValid) {
                memcpy_by_audio_format(buffer, format, mMixerBuffer,
                                       mMixerBufferFormat,
                                       mNormalFrameCount * mChannelCount);
            }
        }

        // 关键: 写入 HAL
        if (mBytesRemaining > 0) {
            mBytesWritten = threadLoop_write();  // <-- 核心
        }

        // 处理需要移除的 Track
        threadLoop_removeTracks(tracksToRemove);
    }

    return false;
}

线程循环流程图

css 复制代码 
┌──────────────────────────────────────────────────────────────┐
│                    PlaybackThread::threadLoop                 │
├──────────────────────────────────────────────────────────────┤
│                                                               │
│   ┌─────────────┐                                             │
│   │ 获取锁 mLock │                                             │
│   └──────┬──────┘                                             │
│          ↓                                                    │
│   ┌─────────────┐      空      ┌───────────────┐              │
│   │ mActiveTracks│ ──────────► │ wait(mLock)   │              │
│   │   isEmpty?  │              │ 等待唤醒      │              │
│   └──────┬──────┘              └───────┬───────┘              │
│          │ 非空                        │                       │
│          ↓                             │                       │
│   ┌─────────────────┐◄─────────────────┘                       │
│   │ prepareTracks_l │◄──── Track::start() 唤醒                 │
│   │ 准备活跃 Tracks │                                            │
│   └──────┬──────────┘                                            │
│          ↓                                                    │
│   ┌─────────────┐                                             │
│   │ 释放锁 mLock │                                             │
│   └──────┬──────┘                                             │
│          ↓                                                    │
│   ┌───────────────────┐                                       │
│   │ mMixerStatus ==    │                                       │
│   │ MIXER_TRACKS_READY?│                                       │
│   └──────┬────────────┘                                       │
│          │ YES                                                │
│          ↓                                                    │
│   ┌─────────────────┐                                       │
│   │ threadLoop_mix  │ ──► mAudioMixer->process()             │
│   │ 混音处理        │                                       │
│   └──────┬──────────┘                                       │
│          ↓                                                    │
│   ┌─────────────────┐                                       │
│   │ threadLoop_write│ ──► mOutput->write() ──► HAL           │
│   │ 写入 HAL        │                                       │
│   └──────┬──────────┘                                       │
│          │                                                    │
│          ↓                                                    │
│   ┌──────────────────┐                                       │
│   │ 下一轮循环       │◄──────────────────────────────────────┤
│   └──────────────────┘                                       │
│                                                               │
└──────────────────────────────────────────────────────────────┘

8. AudioMixer 混音处理

MixerThread::prepareTracks_l()

文件: frameworks/av/services/audioflinger/Threads.cpp (line 5320-5514)

cpp 复制代码 
AudioFlinger::PlaybackThread::mixer_state
AudioFlinger::MixerThread::prepareTracks_l(Vector< sp<Track> > *tracksToRemove)
{
    mixer_state mixerStatus = MIXER_IDLE;
    size_t count = mActiveTracks.size();

    // 清理已删除的 Track
    (void)mTracks.processDeletedTrackIds([this](int trackId) {
        if (mAudioMixer->exists(trackId)) {
            mAudioMixer->destroy(trackId);
        }
    });

    // 遍历活跃 Tracks
    for (size_t i=0 ; i<count ; i++) {
        const sp<Track> t = mActiveTracks[i];
        Track* const track = t.get();

        // 处理 Fast Track
        if (track->isFastTrack()) {
            // Fast Track 特殊处理
            int j = track->mFastIndex;
            FastTrack *fastTrack = &state->mFastTracks[j];
            // ...
            continue;
        }

        // 普通 Track 处理
        switch (track->mState) {
        case TrackBase::ACTIVE:
        case TrackBase::RESUMING:
            // Track 活跃, 进行混音准备
            break;
        case TrackBase::PAUSED:
        case TrackBase::STOPPED:
            // Track 暂停或停止, 加入移除列表
            tracksToRemove->add(track);
            continue;
        }

        // 获取 Track 缓冲区数据
        AudioTrackServerProxy *proxy = track->mAudioTrackServerProxy;
        size_t framesReady = proxy->framesReady();

        if (framesReady == 0) {
            // Track 数据不足
            if (track->isStopping() || track->isPaused() || track->isStopped()) {
                tracksToRemove->add(track);
            }
            continue;
        }

        // 设置 AudioMixer Track 参数
        if (!mAudioMixer->exists(track->id())) {
            mAudioMixer->create(track->id());
        }

        // 设置缓冲区提供者
        mAudioMixer->setBufferProvider(track->id(), track);

        // 设置音量
        mAudioMixer->setParameter(track->id(), AudioMixerBase::VOLUME,
                                  AudioMixerBase::VOLUME0, &volumeLeft);
        mAudioMixer->setParameter(track->id(), AudioMixerBase::VOLUME,
                                  AudioMixerBase::VOLUME1, &volumeRight);

        // 启用 Track
        mAudioMixer->enable(track->id());

        mixedTracks++;
        mixerStatus = MIXER_TRACKS_READY;
    }

    return mixerStatus;
}

MixerThread::threadLoop_mix()

文件: frameworks/av/services/audioflinger/Threads.cpp (line 5248-5264)

cpp 复制代码 
void AudioFlinger::MixerThread::threadLoop_mix()
{
    // 关键: 执行混音
    mAudioMixer->process();  // <-- 核心

    mCurrentWriteLength = mSinkBufferSize;

    // 处理休眠时间
    if ((mSleepTimeUs == 0) && (sleepTimeShift > 0)) {
        sleepTimeShift--;
    }
    mSleepTimeUs = 0;
    mStandbyTimeNs = systemTime() + mStandbyDelayNs;
}

AudioMixer::process()

文件: frameworks/av/media/libaudioprocessing/AudioMixerBase.cpp

cpp 复制代码 
void AudioMixerBase::process__validate()
{
    // 验证 Track 配置
    bool all16BitsStereoNoResample = true;
    bool resampling = false;

    mEnabled.clear();

    for (const auto &pair : mTracks) {
        const int name = pair.first;
        const std::shared_ptr<TrackBase> &t = pair.second;
        if (!t->enabled) continue;

        mEnabled.emplace_back(name);

        // 检查是否需要重采样
        if (t->doesResample()) {
            resampling = true;
            t->hook = TrackBase::getTrackHook(TRACKTYPE_RESAMPLE, ...);
        } else {
            t->hook = TrackBase::getTrackHook(TRACKTYPE_NORESAMPLE, ...);
        }
    }

    // 选择处理函数
    if (resampling) {
        mHook = &AudioMixerBase::process__genericResampling;
    } else {
        mHook = &AudioMixerBase::process__genericNoResampling;
    }

    // 执行处理
    process();
}

void AudioMixerBase::process()
{
    // 调用选定的处理函数
    (this->*mHook)();  // <-- 混音操作
}

混音流程图

scss 复制代码 
┌─────────────────────────────────────────────────────────────┐
│                     AudioMixer 混音流程                      │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│  ┌────────────────┐                                         │
│  │ prepareTracks_l│                                         │
│  │ 遍历活跃 Tracks │                                         │
│  └───────┬───────┬──────────────────────┐                   │
│          │       │                      │                   │
│  Track1  │ Track2│      Track3          │                   │
│          │       │                      │                   │
│  ┌───────┴───────┴──────────────────────┴───────┐           │
│  │              mAudioMixer->process()          │           │
│  └──────────────────────┬───────────────────────┘           │
│                         │                                    │
│                         ↓                                    │
│  ┌─────────────────────────────────────────────────┐        │
│  │ process__validate()                              │        │
│  │ - 检查 Track 配置                                 │        │
│  │ - 设置 hook 函数                                  │        │
│  │ - 选择处理类型                                    │        │
│  └────────────────────────┬────────────────────────┘        │
│                           │                                  │
│           ┌───────────────┼───────────────┐                 │
│           │               │               │                 │
│  ┌────────┴────────┐ ┌────┴────┐ ┌───────┴────────┐        │
│  │ process__generic│ │ process │ │ process__one   │        │
│  │ NoResampling    │ │ __nop   │ │ TrackNoResample│        │
│  │ (无重采样)      │ │(空操作) │ │ (单Track优化)  │        │
│  └────────┬────────┘ └─────────┘ └────────┬───────┘        │
│           │                                    │            │
│           └────────────────┬───────────────────┘            │
│                            ↓                                 │
│  ┌──────────────────────────────────────────────────┐       │
│  │               mMixerBuffer (混音结果)             │       │
│  └────────────────────────┬─────────────────────────┘       │
│                           │                                  │
│                           ↓                                  │
│  ┌──────────────────────────────────────────────────┐       │
│  │                  mSinkBuffer                      │       │
│  │            (拷贝到输出缓冲区)                      │       │
│  └──────────────────────────────────────────────────┘       │
│                                                              │
└─────────────────────────────────────────────────────────────┘

9. HAL 写入流程

threadLoop_write()

文件: frameworks/av/services/audioflinger/Threads.cpp (line 3403-3472)

cpp 复制代码 
ssize_t AudioFlinger::PlaybackThread::threadLoop_write()
{
    mInWrite = true;
    ssize_t bytesWritten;
    const size_t offset = mCurrentWriteLength - mBytesRemaining;

    // 如果使用 NBAIO sink
    if (mNormalSink != 0) {
        const size_t count = mBytesRemaining / mFrameSize;

        ATRACE_BEGIN("write");
        ssize_t framesWritten = mNormalSink->write(
                (char *)mSinkBuffer + offset, count);
        ATRACE_END();

        if (framesWritten > 0) {
            bytesWritten = framesWritten * mFrameSize;
        } else {
            bytesWritten = framesWritten;
        }
    } else {
        // 直接写入 HAL / AudioStreamOut
        if (mUseAsyncWrite) {
            mWriteAckSequence += 2;
            mWriteAckSequence |= 1;
            mCallbackThread->setWriteBlocked(mWriteAckSequence);
        }

        ATRACE_BEGIN("write");
        // 关键: 写入 Audio HAL
        bytesWritten = mOutput->write(
                (char *)mSinkBuffer + offset, mBytesRemaining);  // <-- HAL 写入
        ATRACE_END();
    }

    mNumWrites++;
    mInWrite = false;

    if (mStandby) {
        mThreadMetrics.logBeginInterval();
        mThreadSnapshot.onBegin();
        mStandby = false;
    }

    return bytesWritten;
}

AudioStreamOut 与 HAL

arduino 复制代码 
┌─────────────────────────────────────────────────────────────┐
│                    HAL 写入层级                              │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│  PlaybackThread                                              │
│       │                                                      │
│       ↓                                                      │
│  mOutput (AudioStreamOut*)                                   │
│       │                                                      │
│       ↓                                                      │
│  AudioStreamOut::write()                                     │
│       │                                                      │
│       ↓                                                      │
│  StreamOutHalInterface                                       │
│       │                                                      │
│       ↓                                                      │
│  Audio HAL (HAL 实现)                                        │
│       │                                                      │
│       ↓                                                      │
│  硬件设备 (Speaker/Headphone/蓝牙等)                         │
│                                                              │
└─────────────────────────────────────────────────────────────┘

10. 完整流程图

scss 复制代码 
┌─────────────────────────────────────────────────────────────────────────────┐
│                        AudioTrack.start() 完整执行流程                        │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                              │
│  ┌───────────────────┐                                                       │
│  │    Java Layer     │                                                       │
│  │  AudioTrack.start │                                                       │
│  └─────────────┬─────┘                                                       │
│                │                                                              │
│                ↓                                                              │
│  ┌───────────────────┐                                                       │
│  │    JNI Layer      │                                                       │
│  │ android_media_    │                                                       │
│  │ AudioTrack_start  │                                                       │
│  │                   │                                                       │
│  │ lpTrack->start()  │                                                       │
│  └─────────────┬─────┘                                                       │
│                │                                                              │
│                ↓                                                              │
│  ┌───────────────────────────────────────────────────────┐                  │
│  │              Native AudioTrack Layer                  │                  │
│  │                                                       │                  │
│  │  AudioTrack::start()                                  │                  │
│  │    - mState = STATE_ACTIVE                            │                  │
│  │    - mAudioTrack->start(&status)                      │◄─ IAudioTrack   │
│  │                                                       │                  │
│  │  IAudioTrack 创建流程:                                │                  │
│  │  AudioTrack::createTrack_l()                          │                  │
│  │    - AudioSystem::get_audio_flinger()                 │                  │
│  │    - audioFlinger->createTrack()                      │◄─ Binder IPC    │
│  └─────────────────────────────┬─────────────────────────┘                  │
│                                │                                             │
│                                │ Binder IPC                                  │
│                                ↓                                             │
│  ┌───────────────────────────────────────────────────────┐                  │
│  │                  AudioFlinger Service                 │                  │
│  │                                                       │                  │
│  │  AudioFlinger::createTrack()                          │                  │
│  │    - 获取 PlaybackThread                              │                  │
│  │    - thread->createTrack_l() 创建 Track               │                  │
│  │    - new TrackHandle(track) 创建 Binder 服务端        │                  │
│  │                                                       │                  │
│  │  TrackHandle::start()                                 │                  │
│  │    - mTrack->start()                                  │                  │
│  └─────────────────────────────┬─────────────────────────┘                  │
│                                │                                             │
│                                ↓                                             │
│  ┌───────────────────────────────────────────────────────┐                  │
│  │                  PlaybackThread::Track                │                  │
│  │                                                       │                  │
│  │  Track::start()                                       │                  │
│  │    - mState = ACTIVE                                  │                  │
│  │    - playbackThread->addTrack_l(this)                 │                  │
│  └─────────────────────────────┬─────────────────────────┘                  │
│                                │                                             │
│                                ↓                                             │
│  ┌───────────────────────────────────────────────────────┐                  │
│  │                   PlaybackThread                      │                  │
│  │                                                       │                  │
│  │  addTrack_l()                                         │                  │
│  │    - AudioSystem::startOutput()                       │                  │
│  │    - mActiveTracks.add(track)                         │◄─ 添加到活跃列表 │
│  │    - onAddNewTrack_l() 唤醒线程                       │                  │
│  └─────────────────────────────┬─────────────────────────┘                  │
│                                │                                             │
│                                │ 唤醒                                        │
│                                ↓                                             │
│  ┌───────────────────────────────────────────────────────┐                  │
│  │               PlaybackThread::threadLoop              │                  │
│  │                                                       │                  │
│  │  ┌─────────────────────────────────────────────┐     │                  │
│  │  │              主循环                          │     │                  │
│  │  │                                             │     │                  │
│  │  │ prepareTracks_l(&tracksToRemove)            │     │                  │
│  │  │   - 遍历 mActiveTracks                      │     │                  │
│  │  │   - 配置 AudioMixer                         │     │                  │
│  │  │   - 设置 Track 参数                         │     │                  │
│  │  │                                             │     │                  │
│  │  │ threadLoop_mix()                            │     │                  │
│  │  │   - mAudioMixer->process()                  │     │◄─ 混音            │
│  │  │   - 输出到 mMixerBuffer                     │     │                  │
│  │  │                                             │     │                  │
│  │  │ threadLoop_write()                          │     │                  │
│  │  │   - mOutput->write()                        │     │◄─ 写入 HAL        │
│  │  │   - AudioStreamOut -> HAL                   │     │                  │
│  │  └─────────────────────────────────────────────┘     │                  │
│  └───────────────────────────────────────────────────────┘                  │
│                                                                              │
└─────────────────────────────────────────────────────────────────────────────┘

11. 关键数据结构

audio_track_cblk_t (Control Block)

共享内存控制块，用于客户端和服务端之间传递音频数据和状态信息：

cpp 复制代码 
struct audio_track_cblk_t {
    volatile int32_t    mFlags;         // 标志位
    volatile uint32_t   mPosition;      // 位置
    volatile uint32_t   mServer;        // 服务端位置
    volatile uint32_t   mFrameCount;    // 帧计数
    // ...
};

Track 状态枚举

cpp 复制代码 
enum track_state {
    IDLE,
    STOPPED,
    FLUSHED,
    PAUSED,
    PAUSING,
    RESUMING,
    ACTIVE,
    STOPPING_1,
    STOPPING_2,
};

mixer_state 枚举

cpp 复制代码 
enum mixer_state {
    MIXER_IDLE,
    MIXER_TRACKS_ENABLED,    // Track 启用但数据不足
    MIXER_TRACKS_READY,      // Track 有数据可以混音
    MIXER_DRAIN_TRACK,       // 等待 Track 数据处理完成
    MIXER_DRAIN_ALL,         // 等待所有数据处理完成
};

12. 总结

执行流程总结

层级 类/方法 主要职责
Java AudioTrack.start() 用户调用入口
JNI android_media_AudioTrack_start JNI 桥接
Native AudioTrack::start() 状态管理，发起 binder 调用
Binder IAudioTrack::start() 跨进程通信
AudioFlinger TrackHandle::start() Binder 服务端处理
AudioFlinger Track::start() Track 状态设置
AudioFlinger PlaybackThread::addTrack_l() 添加到活跃列表，唤醒线程
AudioFlinger PlaybackThread::threadLoop 主循环处理
AudioFlinger MixerThread::prepareTracks_l 准备混音参数
AudioMixer AudioMixer::process 执行混音操作
AudioFlinger PlaybackThread::threadLoop_write 写入 HAL

关键路径文件

  1. JNI : frameworks/base/core/jni/android_media_AudioTrack.cpp
  2. Native AudioTrack : frameworks/av/media/libaudioclient/AudioTrack.cpp
  3. IAudioTrack接口 : frameworks/av/media/libaudioclient/aidl/android/media/IAudioTrack.aidl
  4. AudioFlinger : frameworks/av/services/audioflinger/AudioFlinger.cpp
  5. Track实现 : frameworks/av/services/audioflinger/Tracks.cpp
  6. PlaybackThread : frameworks/av/services/audioflinger/Threads.cpp
  7. AudioMixer : frameworks/av/media/libaudioprocessing/AudioMixer.cpp
  8. AudioMixerBase : frameworks/av/media/libaudioprocessing/AudioMixerBase.cpp

参考文献

  • AOSP 14.0.0_r21 源代码
  • Android Audio System Architecture Documentation
相关推荐
千里马学框架3 天前
一起学 Android 14：ShellTransition 屏幕旋转过程深度剖析
android·智能手机·性能优化·framework·性能·屏幕旋转·rotation
美狐美颜SDK开放平台3 天前
开发直播APP时如何接入视频美颜SDK？开发流程与注意事项
android·人工智能·计算机视觉·音视频·直播美颜sdk
AFinalStone3 天前
Android7 SystemUI源码解析（七）Keyguard锁屏模块深度解析
android·systemui
致远ccc3 天前
Google Play 上架前如何测试 App？多国家 Android 环境测试
android·app测试·googleplay·多国家应用测试
ttyyttemo3 天前
Kotlin 协程中的 Job 结构化并发与取消
android
sun0077003 天前
tbox 4g/5g切换，导致wan ip 改变，导致车机旧网络不可用。需要重启车机才行
android
其实防守也摸鱼3 天前
内网穿透与反向代理：原理、工具与实战指南
android·大数据·运维·安全·网络安全·自动化·渗透
AFinalStone3 天前
Android7 SystemUI 源码解析（四）NavigationBar 导航栏与 SystemBars
android·systemui
JMchen3 天前
属性动画原理与高级动画实现
android·kotlin·canvas
AFinalStone3 天前
Android7 SystemUI 源码解析（二）启动流程深度解析
android·systemui
热门推荐
01国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）02Telegram APK 下载安装完整指南 — 2026年最新03GitHub 镜像站点042026 爱知・名古屋亚运会怎么看？直播平台+赛程安排分享05历年考研数学一、数学二、数学三真题试卷及答案PDF06蜘蛛磁力 搜索引擎大全，如何使用蜘蛛磁力查找磁力链接072026年CSP-J初赛分数线-----预测08微信历史版本含下载地址（ Windows PC | 安卓 | MAC ）及设置微信不更新092026 国产 AI 大模型横评：DeepSeek、通义千问、Kimi、文心一言、星火、豆包谁更能打？10人工智能（AI）发展史：详细里程碑