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
相关推荐
众少成多积小致巨2 小时前
Android 初始化语言入门
android·linux·c++
Carson带你学Android2 小时前
谁才是地表最强 Android Agent 大模型？Google官方测评来了！
android·openai
followYouself2 小时前
ASM开源库实现函数耗时插桩
android·asm·asm插桩·字节码插桩
TO_ZRG3 小时前
Android Content Provider 基础
android·jvm·oracle
studyForMokey3 小时前
【Android面试】数据库
android·数据库·面试
胡利光3 小时前
Harness Engineering 03｜Eval & Trace Harness：验证和追溯的工程组织
android·开发语言·kotlin
jvvz afqh3 小时前
MySQL Workbench菜单汉化为中文
android·数据库·mysql
aaajj3 小时前
【Android】防骚扰电话自动接听助手方案
android·人工智能
QCzblack3 小时前
php-ser-libs
android·开发语言·php
热门推荐
01GitHub 镜像站点02近期有什么ai的新消息，新动态？ 2026.4月032026年4月AI大事件深度解读：大模型竞争进入“深水区“042026年AI前瞻：量子AI、具身智能与科学发现的新纪元052026年4月技术前沿：AI大模型爆发、智能体革命与量子安全新纪元06codex app每次打开重连5次Reconnecting问题解决072026年AI编程工具终极横评：Cursor vs Claude Code vs Copilot08AI Weekly | 2026年4月第二周 · GitHub热门项目与AI发展趋势深度解析09DeepSeek V4 全面解析：测评、对比、案例及实操指南10Codex 接入 DeepSeek API 完整配置文档