Android10 音频系统之AudioTrack

原创 已于 2025-03-12 15:06:39 修改 · 2.2k 阅读 · 37 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
于 2024-06-17 17:56:45 首次发布

        Android上使用AudioTrack可以实现播放PCM。本文深入分析了Android的AudioTrack.cpp源码，详细解释了从AudioTrack.java到AudioTrack.cpp的工作流程。主要内容包括获取缓冲区最小值、AudioTrack对象的创建、音频数据的写入以及停止和释放方法

//1. 根据音频数据的特性来确定所要分配的缓冲区的最小size
int bufsize =AudioTrack.getMinBufferSize(8000,//采样率：每秒8K个点
　　           AudioFormat.CHANNEL_CONFIGURATION_STEREO,//声道数：双声道           
                AudioFormat.ENCODING_PCM_16BIT//采样精度：一个采样点16比特，相当于2个字节
             );
//2. 创建AudioTrack
AudioTrack trackplayer = new AudioTrack(
                 AudioManager.STREAM_MUSIC,//音频流类型
                 8000,
                 AudioFormat.CHANNEL_CONFIGURATION_ STEREO,
　　             AudioFormat.ENCODING_PCM_16BIT, bufsize,
                 AudioTrack.MODE_STREAM//数据加载模式);
//3. 开始播放
trackplayer.play() ;
//4. 调用write写数据
trackplayer.write(bytes_pkg, 0,bytes_pkg.length) ;//往track中写数据
//5. 停止播放和释放资源
trackplayer.stop();//停止播放
trackplayer.release();//释放底层资源

1. 获取最小缓存

xref: /frameworks/base/media/java/android/media/AudioTrack.java

static public int getMinBufferSize(int sampleRateInHz, int channelConfig, int audioFormat) {
    int channelCount = 0;
    switch(channelConfig) {
    case AudioFormat.CHANNEL_OUT_MONO:
    case AudioFormat.CHANNEL_CONFIGURATION_MONO:
        channelCount = 1;
        break;
    case AudioFormat.CHANNEL_OUT_STEREO:
    case AudioFormat.CHANNEL_CONFIGURATION_STEREO:
        channelCount = 2;// 目前最多支持双声道
        break;
    default:
        if (!isMultichannelConfigSupported(channelConfig)) {
            loge("getMinBufferSize(): Invalid channel configuration.");
            return ERROR_BAD_VALUE;
        } else {
            channelCount = AudioFormat.channelCountFromOutChannelMask(channelConfig);
        }
    }

    if (!AudioFormat.isPublicEncoding(audioFormat)) {
        loge("getMinBufferSize(): Invalid audio format.");
        return ERROR_BAD_VALUE;
    }

    // sample rate, note these values are subject to change
    // Note: AudioFormat.SAMPLE_RATE_UNSPECIFIED is not allowed
    if ( (sampleRateInHz < AudioFormat.SAMPLE_RATE_HZ_MIN) ||
            (sampleRateInHz > AudioFormat.SAMPLE_RATE_HZ_MAX) ) {
        loge("getMinBufferSize(): " + sampleRateInHz + " Hz is not a supported sample rate.");
        return ERROR_BAD_VALUE;
    }
	// 调用native层方法
    int size = native_get_min_buff_size(sampleRateInHz, channelCount, audioFormat);
    if (size <= 0) {
        loge("getMinBufferSize(): error querying hardware");
        return ERROR;
    }
    else {
        return size;
    }
}

        确定输出通道是双声道还是单声道，调用native层的native_get_min_buff_size方法计算最小缓存

xref: /frameworks/base/core/jni/android_media_AudioTrack.cpp

static const JNINativeMethod gMethods[] = {

    {"native_get_min_buff_size",
                             "(III)I",   (void *)android_media_AudioTrack_get_min_buff_size},
    
};


................................................................................................


static jint android_media_AudioTrack_get_min_buff_size(JNIEnv *env,  jobject thiz,
    jint sampleRateInHertz, jint channelCount, jint audioFormat) {

    size_t frameCount;
    const status_t status = AudioTrack::getMinFrameCount(&frameCount, AUDIO_STREAM_DEFAULT,
            sampleRateInHertz);
    if (status != NO_ERROR) {
        ALOGE("AudioTrack::getMinFrameCount() for sample rate %d failed with status %d",
                sampleRateInHertz, status);
        return -1;
    }
    const audio_format_t format = audioFormatToNative(audioFormat);
    if (audio_has_proportional_frames(format)) {
        const size_t bytesPerSample = audio_bytes_per_sample(format);
        //min_buf_size = 所需帧的最小个数 * 声道数 * 一个采样点的字节数
        return frameCount * channelCount * bytesPerSample;
    } else {
        return frameCount;
    }
}

        getMinFrameCount这个函数用于确定至少需要多少Frame才能保证音频的正常播放。
1Frame = 一个采样点的字节数 x 声道数(比如PCM16，双声道的1个Frame等于2×2=4字节)

xref: /frameworks/av/media/libaudioclient/AudioTrack.cpp

status_t AudioTrack::getMinFrameCount(
        size_t* frameCount,
        audio_stream_type_t streamType,
        uint32_t sampleRate)
{
    if (frameCount == NULL) {
        return BAD_VALUE;
    }

    // 查询硬件设备的采样率
    uint32_t afSampleRate;
    status_t status;
    status = AudioSystem::getOutputSamplingRate(&afSampleRate, streamType);
    if (status != NO_ERROR) {
        ALOGE("%s(): Unable to query output sample rate for stream type %d; status %d",
                __func__, streamType, status);
        return status;
    }
	// 查询硬件内部缓冲的大小
    size_t afFrameCount;
    status = AudioSystem::getOutputFrameCount(&afFrameCount, streamType);
    if (status != NO_ERROR) {
        ALOGE("%s(): Unable to query output frame count for stream type %d; status %d",
                __func__, streamType, status);
        return status;
    }
	// 查询硬件的延时时间
    uint32_t afLatency;
    status = AudioSystem::getOutputLatency(&afLatency, streamType);
    if (status != NO_ERROR) {
        ALOGE("%s(): Unable to query output latency for stream type %d; status %d",
                __func__, streamType, status);
        return status;
    }

    // 计算一个最低帧数
    *frameCount = AudioSystem::calculateMinFrameCount(afLatency, afFrameCount, afSampleRate,
                                              sampleRate, 1.0f /*, 0 notificationsPerBufferReq*/);

    // The formula above should always produce a non-zero value under normal circumstances:
    // AudioTrack.SAMPLE_RATE_HZ_MIN <= sampleRate <= AudioTrack.SAMPLE_RATE_HZ_MAX.
    // Return error in the unlikely event that it does not, as that's part of the API contract.
    if (*frameCount == 0) {
        ALOGE("%s(): failed for streamType %d, sampleRate %u",
                __func__, streamType, sampleRate);
        return BAD_VALUE;
    }
    ALOGV("%s(): getMinFrameCount=%zu: afFrameCount=%zu, afSampleRate=%u, afLatency=%u",
            __func__, *frameCount, afFrameCount, afSampleRate, afLatency);
    return NO_ERROR;
}

        查询硬件设备的采样率、硬件内部缓冲的大小、硬件的延时时间然后计算一个最低帧数。

xref: /frameworks/av/media/libaudioclient/AudioSystem.cpp

/* static */ size_t AudioSystem::calculateMinFrameCount(
        uint32_t afLatencyMs, uint32_t afFrameCount, uint32_t afSampleRate,
        uint32_t sampleRate, float speed /*, uint32_t notificationsPerBufferReq*/)
{
    // Ensure that buffer depth covers at least audio hardware latency
    uint32_t minBufCount = afLatencyMs / ((1000 * afFrameCount) / afSampleRate);
    if (minBufCount < 2) {
        minBufCount = 2;
    }
#if 0
    // The notificationsPerBufferReq parameter is not yet used for non-fast tracks,
    // but keeping the code here to make it easier to add later.
    if (minBufCount < notificationsPerBufferReq) {
        minBufCount = notificationsPerBufferReq;
    }
#endif
    ALOGV("calculateMinFrameCount afLatency %u  afFrameCount %u  afSampleRate %u  "
            "sampleRate %u  speed %f  minBufCount: %u" /*"  notificationsPerBufferReq %u"*/,
            afLatencyMs, afFrameCount, afSampleRate, sampleRate, speed, minBufCount
            /*, notificationsPerBufferReq*/);
    return minBufCount * sourceFramesNeededWithTimestretch(
            sampleRate, afFrameCount, afSampleRate, speed);
}

2. AudioTrack的创建

xref: /frameworks/base/media/java/android/media/AudioTrack.java

private AudioTrack(AudioAttributes attributes, AudioFormat format, int bufferSizeInBytes,
        int mode, int sessionId, boolean offload)
                throws IllegalArgumentException {
				
    ........................................................................

	// 检查参数的合法性
    audioParamCheck(rate, channelMask, channelIndexMask, encoding, mode);
    mOffloaded = offload;
    mStreamType = AudioSystem.STREAM_DEFAULT;

    audioBuffSizeCheck(bufferSizeInBytes);

    mInitializationLooper = looper;

    if (sessionId < 0) {
        throw new IllegalArgumentException("Invalid audio session ID: "+sessionId);
    }

    int[] sampleRate = new int[] {mSampleRate};
    int[] session = new int[1];
    session[0] = sessionId;
    // native initialization
	// 调用natvie层的native_setup方法
    int initResult = native_setup(new WeakReference<AudioTrack>(this), mAttributes,
            sampleRate, //传入的这个值是8000
			mChannelMask, //传入的这个值是2
			mChannelIndexMask, 
			mAudioFormat, //传入的这个值是AudioFormat.ENCODING_PCM_16BIT    
            mNativeBufferSizeInBytes, //传入的这个值是bufferSizeInBytes              
			mDataLoadMode, //传入的这个值是MODE_STREAM
			session, 0 /*nativeTrackInJavaObj*/,
            offload);
    if (initResult != SUCCESS) {
        loge("Error code "+initResult+" when initializing AudioTrack.");
        return; // with mState == STATE_UNINITIALIZED
    }

    ........................................................................
}

        检查参数的合法性，调用native层的native_setup方法

xref: /frameworks/base/core/jni/android_media_AudioTrack.cpp        

static const JNINativeMethod gMethods[] = {
    {"native_setup",     "(Ljava/lang/Object;Ljava/lang/Object;[IIIIII[IJZ)I",
                                         (void *)android_media_AudioTrack_setup},
};




android_media_AudioTrack_setup(JNIEnv *env, jobject thiz, jobject weak_this, jobject jaa,
        jintArray jSampleRate, jint channelPositionMask, jint channelIndexMask,
        jint audioFormat, jint buffSizeInBytes, jint memoryMode, jintArray jSession,
        jlong nativeAudioTrack, jboolean offload) {

    sp<AudioTrack> lpTrack = 0;

    ......................................................................................

    // if we pass in an existing *Native* AudioTrack, we don't need to create/initialize one.
    if (nativeAudioTrack == 0) {   

        ......................................................................................

        // create the native AudioTrack object
        lpTrack = new AudioTrack();

        ......................................................................................

        // 对两种模式(MODE_STREAM和MODE_STATIC)进行区分
        switch (memoryMode) {
        case MODE_STREAM:
			// 设置参数，这里的app不分配内存而是在后面的playbackthread中分配内存
            status = lpTrack->set(
                    AUDIO_STREAM_DEFAULT,// stream type, but more info conveyed in paa (last argument)
                    sampleRateInHertz,
                    format,// 采样点的精度，一般为PCM16或者PCM8
                    nativeChannelMask,
                    offload ? 0 : frameCount,
                    offload ? AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD : AUDIO_OUTPUT_FLAG_NONE,
                    audioCallback, //该回调函数定义在android_media_AudioTrack.cpp中   
					&(lpJniStorage->mCallbackData),//callback, callback data (user)
                    0,// notificationFrames == 0 since not using EVENT_MORE_DATA to feed the AudioTrack
                    0,/ 共享内存,STREAM模式下为空。实际使用的共享内存由AF创建
                    true,// thread can call Java
                    sessionId,// audio session ID
                    offload ? AudioTrack::TRANSFER_SYNC_NOTIF_CALLBACK : AudioTrack::TRANSFER_SYNC,
                    offload ? &offloadInfo : NULL,
                    -1, -1,                       // default uid, pid values
                    paa.get());

            break;

        case MODE_STATIC:
            // 如果是static模式，需要先创建共享内存
            if (!lpJniStorage->allocSharedMem(buffSizeInBytes)) {
                ALOGE("Error creating AudioTrack in static mode: error creating mem heap base");
                goto native_init_failure;
            }

            status = lpTrack->set(
                    AUDIO_STREAM_DEFAULT,// stream type, but more info conveyed in paa (last argument)
                    sampleRateInHertz,
                    format,// word length, PCM
                    nativeChannelMask,
                    frameCount,
                    AUDIO_OUTPUT_FLAG_NONE,
                    audioCallback, &(lpJniStorage->mCallbackData),//callback, callback data (user));
                    0,// notificationFrames == 0 since not using EVENT_MORE_DATA to feed the AudioTrack
                    lpJniStorage->mMemBase,// STATIC模式下，需要传递该共享内存
                    true,// thread can call Java
                    sessionId,// audio session ID
                    AudioTrack::TRANSFER_SHARED,
                    NULL,                         // default offloadInfo
                    -1, -1,                       // default uid, pid values
                    paa.get());
            break;

        ............................................................................................
		
    } 
    // 把JNI层中new出来的AudioTrack对象指针保存到Java对象的一个变量中
    setAudioTrack(env, thiz, lpTrack);

    // save the JNI resources so we can free them later
    // lpJniStorage对象指针也保存到Java对象中
    env->SetLongField(thiz, javaAudioTrackFields.jniData, (jlong)lpJniStorage);

    return (jint) AUDIO_JAVA_SUCCESS;

    ............................................................................................
}

3. 开始播放

xref: /frameworks/base/media/java/android/media/AudioTrack.java

public void play()
throws IllegalStateException {

     .........................................................................................
	 
    final int delay = getStartDelayMs();
    if (delay == 0) {
        startImpl();
    } else {
        new Thread() {
            public void run() {
			
                .........................................................................................
				
                try {
                    startImpl();
                } catch (IllegalStateException e) {
                    // fail silently for a state exception when it is happening after
                    // a delayed start, as the player state could have changed between the
                    // call to start() and the execution of startImpl()
                }
            }
        }.start();
    }
}

.........................................................................................

private void startImpl() {
    synchronized(mPlayStateLock) {
        baseStart();
        // 调用native层的start方法
        native_start();
        
		.........................................................................................
		
    }
}

        调用native层的start方法

xref: /frameworks/base/core/jni/android_media_AudioTrack.cpp

static const JNINativeMethod gMethods[] = {
    {"native_start",         "()V",      (void *)android_media_AudioTrack_start},
};

.....................................................................................

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();
}

        调用AudioTrack的start方法

xref: /frameworks/av/media/libaudioclient/AudioTrack.cpp

status_t AudioTrack::start()
{
    // 如果已经是start状态则返回
    if (mState == STATE_ACTIVE) {
        return INVALID_OPERATION;
    }

    mInUnderrun = true;
	// 保存上一次的状态
    State previousState = mState;
    if (previousState == STATE_PAUSED_STOPPING) {
        mState = STATE_STOPPING;
    } else {
        mState = STATE_ACTIVE;
    }
	
    .................................................................................
	
    // 如果上一状态是停止状态，表明需要重新把position设置为0，从头播放
    if (previousState == STATE_STOPPED || previousState == STATE_FLUSHED) {
        // reset current position as seen by client to 0
        mPosition = 0;
        mPreviousTimestampValid = false;
        mTimestampStartupGlitchReported = false;
        mTimestampRetrogradePositionReported = false;
        mTimestampRetrogradeTimeReported = false;
        mTimestampStallReported = false;
        mTimestampStaleTimeReported = false;
        mPreviousLocation = ExtendedTimestamp::LOCATION_INVALID;

        if (!isOffloadedOrDirect_l()
                && mStartEts.mTimeNs[ExtendedTimestamp::LOCATION_SERVER] > 0) {
            // Server side has consumed something, but is it finished consuming?
            // It is possible since flush and stop are asynchronous that the server
            // is still active at this point.
            ALOGV("%s(%d): server read:%lld  cumulative flushed:%lld  client written:%lld",
                    __func__, mPortId,
                    (long long)(mFramesWrittenServerOffset
                            + mStartEts.mPosition[ExtendedTimestamp::LOCATION_SERVER]),
                    (long long)mStartEts.mFlushed,
                    (long long)mFramesWritten);
            // mStartEts is already adjusted by mFramesWrittenServerOffset, so we delta adjust.
            mFramesWrittenServerOffset -= mStartEts.mPosition[ExtendedTimestamp::LOCATION_SERVER];
        }
        mFramesWritten = 0;
        mProxy->clearTimestamp(); // need new server push for valid timestamp
        mMarkerReached = false;

        // For offloaded tracks, we don't know if the hardware counters are really zero here,
        // since the flush is asynchronous and stop may not fully drain.
        // We save the time when the track is started to later verify whether
        // the counters are realistic (i.e. start from zero after this time).
        mStartFromZeroUs = mStartNs / 1000;

        // force refresh of remaining frames by processAudioBuffer() as last
        // write before stop could be partial.
        mRefreshRemaining = true;

        // for static track, clear the old flags when starting from stopped state
        if (mSharedBuffer != 0) {
            android_atomic_and(
            ~(CBLK_LOOP_CYCLE | CBLK_LOOP_FINAL | CBLK_BUFFER_END),
            &mCblk->mFlags);
        }
    }
	// 新的播放位置
    mNewPosition = mPosition + mUpdatePeriod;
	// 获取share buffer的flag
    int32_t flags = android_atomic_and(~(CBLK_STREAM_END_DONE | CBLK_DISABLED), &mCblk->mFlags);

	status_t status = NO_ERROR;
	if (!(flags & CBLK_INVALID)) {
		// 如果share buffer可用，则调用track的start方法
		status = mAudioTrack->start();
		if (status == DEAD_OBJECT) {
			flags |= CBLK_INVALID;
		}
	}
	if (flags & CBLK_INVALID) {
		status = restoreTrack_l("start");
	}

    // resume or pause the callback thread as needed.
    sp<AudioTrackThread> t = mAudioTrackThread;
    if (status == NO_ERROR) {
        if (t != 0) {
            if (previousState == STATE_STOPPING) {
				// 中断
                mProxy->interrupt();
            } else {
				// 恢复播放
                t->resume();
            }
        } else {
			// 获取当前线程的优先级
            mPreviousPriority = getpriority(PRIO_PROCESS, 0);
            get_sched_policy(0, &mPreviousSchedulingGroup);
			// 设置线程优先级为ANDROID_PRIORITY_AUDIO
            androidSetThreadPriority(0, ANDROID_PRIORITY_AUDIO);
        }

        // Start our local VolumeHandler for restoration purposes.
        mVolumeHandler->setStarted();
    } else {
        ALOGE("%s(%d): status %d", __func__, mPortId, status);
        mState = previousState;
        if (t != 0) {
            if (previousState != STATE_STOPPING) {
                t->pause();
            }
        } else {
            setpriority(PRIO_PROCESS, 0, mPreviousPriority);
            set_sched_policy(0, mPreviousSchedulingGroup);
        }
    }

    return status;
}

4. 调用write写数据

xref: /frameworks/base/media/java/android/media/AudioTrack.java

public int write(@NonNull short[] audioData, int offsetInShorts, int sizeInShorts,
        @WriteMode int writeMode) {

    .........................................................................................

    final int ret = native_write_short(audioData, offsetInShorts, sizeInShorts, mAudioFormat,
            writeMode == WRITE_BLOCKING);

    if ((mDataLoadMode == MODE_STATIC)
            && (mState == STATE_NO_STATIC_DATA)
            && (ret > 0)) {
        // benign race with respect to other APIs that read mState
        mState = STATE_INITIALIZED;
    }

    return ret;
}

      我们的用例中采用的是PCM16数据。它对应的JNI层函数native_write_short。

xref: /frameworks/base/core/jni/android_media_AudioTrack.cpp

static const JNINativeMethod gMethods[] = {    
    {"native_write_short",   "([SIIIZ)I",(void *)android_media_AudioTrack_writeArray<jshortArray>},    
};

...................................................................................................

static jint android_media_AudioTrack_writeArray(JNIEnv *env, jobject thiz,
                                                T javaAudioData,
                                                jint offsetInSamples, jint sizeInSamples,
                                                jint javaAudioFormat,
                                                jboolean isWriteBlocking) {
    //ALOGV("android_media_AudioTrack_writeArray(offset=%d, sizeInSamples=%d) called",
    //        offsetInSamples, sizeInSamples);
    sp<AudioTrack> lpTrack = getAudioTrack(env, thiz);
    
	........................................................................................

	// 无论是PCM16还是PCM8数据，最终都会调用writeToTrack函数
    jint samplesWritten = writeToTrack(lpTrack, javaAudioFormat, cAudioData,
            offsetInSamples, sizeInSamples, isWriteBlocking == JNI_TRUE /* blocking */);

    envReleaseArrayElements(env, javaAudioData, cAudioData, 0);

    return samplesWritten;
}

        无论是PCM16还是PCM8数据，最终都会调用writeToTrack函数

static jint writeToTrack(const sp<AudioTrack>& track, jint audioFormat, const T *data,
                         jint offsetInSamples, jint sizeInSamples, bool blocking) {
    // give the data to the native AudioTrack object (the data starts at the offset)
    ssize_t written = 0;
    // regular write() or copy the data to the AudioTrack's shared memory?
    size_t sizeInBytes = sizeInSamples * sizeof(T);
    if (track->sharedBuffer() == 0) { // STREAM模式
		// 调用write函数写数据
        written = track->write(data + offsetInSamples, sizeInBytes, blocking);
        // for compatibility with earlier behavior of write(), return 0 in this case
        if (written == (ssize_t) WOULD_BLOCK) {
            written = 0;
        }
    } else {// STATIC模式
        // writing to shared memory, check for capacity
        if ((size_t)sizeInBytes > track->sharedBuffer()->size()) {
            sizeInBytes = track->sharedBuffer()->size();
        }
		// 在STATIC模式下，直接把数据memcpy到共享内存，但是这种模式下要先调用write然后再play
        memcpy(track->sharedBuffer()->pointer(), data + offsetInSamples, sizeInBytes);
        written = sizeInBytes;
    }
    if (written >= 0) {
        return written / sizeof(T);
    }
    return interpretWriteSizeError(written);
}

        AudioTrack有两种数据加载模式：MODE_STREAM和MODE_STATIC，它们对应着两种完全不同的使用场景。

        MODE_STREAM：在这种模式下，通过write一次次把音频数据写到AudioTrack中。这和平时通过write系统调用往文件中写数据类似，但这种工作方式每次都需要把数据从用户提供的Buffer中拷贝到AudioTrack内部的Buffer中，这在一定程度上会使引入延时。为解决这一问题，AudioTrack就引入了第二种模式。

        MODE_STATIC：这种模式下，在play之前只需要把所有数据通过一次write调用传递到AudioTrack中的内部缓冲区，后续就不必再传递数据了。这种模式适用于像铃声这种内存占用量较小，延时要求较高的文件。但它也有一个缺点，就是一次write的数据不能太多，否则系统无法分配足够的内存来存储全部数据。

5.调用release释放资源

xref: /frameworks/base/media/java/android/media/AudioTrack.java

public void release() {
    synchronized (mStreamEventCbLock){
        endStreamEventHandling();
    }
    // even though native_release() stops the native AudioTrack, we need to stop
    // AudioTrack subclasses too.
    try {
        stop();
    } catch(IllegalStateException ise) {
        // don't raise an exception, we're releasing the resources.
    }
    baseRelease();
    native_release();
    synchronized (mPlayStateLock) {
        mState = STATE_UNINITIALIZED;
        mPlayState = PLAYSTATE_STOPPED;
        mPlayStateLock.notify();
    }
}

        先调用stop方法停止播放，在调用native_release方法释放资源

public void stop()
throws IllegalStateException {
    if (mState != STATE_INITIALIZED) {
        throw new IllegalStateException("stop() called on uninitialized AudioTrack.");
    }

    // stop playing
    synchronized(mPlayStateLock) {
        native_stop();
        baseStop();
        if (mOffloaded && mPlayState != PLAYSTATE_PAUSED_STOPPING) {
            mPlayState = PLAYSTATE_STOPPING;
        } else {
            mPlayState = PLAYSTATE_STOPPED;
            mOffloadEosPending = false;
            mAvSyncHeader = null;
            mAvSyncBytesRemaining = 0;
            mPlayStateLock.notify();
        }
    }
}

        调用native_stop方法

static const JNINativeMethod gMethods[] = {
    {"native_stop",          "()V",      (void *)android_media_AudioTrack_stop},    
};

................................................................................

android_media_AudioTrack_stop(JNIEnv *env, jobject thiz)
{
    sp<AudioTrack> lpTrack = getAudioTrack(env, thiz);
    if (lpTrack == NULL) {
        jniThrowException(env, "java/lang/IllegalStateException",
            "Unable to retrieve AudioTrack pointer for stop()");
        return;
    }
    // 停止播放
    lpTrack->stop();
}

        停止播放，接下来调用release方法释放资源

static const JNINativeMethod gMethods[] = {
	{"native_release",       "()V",      (void *)android_media_AudioTrack_release},
};

....................................................................................

static void android_media_AudioTrack_release(JNIEnv *env,  jobject thiz) {
    sp<AudioTrack> lpTrack = setAudioTrack(env, thiz, 0);
    if (lpTrack == NULL) {
        return;
    }
    //ALOGV("deleting lpTrack: %x\n", (int)lpTrack);

    // delete the JNI data
    AudioTrackJniStorage* pJniStorage = (AudioTrackJniStorage *)env->GetLongField(
        thiz, javaAudioTrackFields.jniData);
    // 之前保存在Java对象中的指针变量此时都要设置为零
    env->SetLongField(thiz, javaAudioTrackFields.jniData, 0);

    if (pJniStorage) {
        Mutex::Autolock l(sLock);
        audiotrack_callback_cookie *lpCookie = &pJniStorage->mCallbackData;
        //ALOGV("deleting pJniStorage: %x\n", (int)pJniStorage);
        while (lpCookie->busy) {
            if (lpCookie->cond.waitRelative(sLock,
                                            milliseconds(CALLBACK_COND_WAIT_TIMEOUT_MS)) !=
                                                    NO_ERROR) {
                break;
            }
        }
        sAudioTrackCallBackCookies.remove(lpCookie);
        // 删除引用
        env->DeleteGlobalRef(lpCookie->audioTrack_class);
        env->DeleteGlobalRef(lpCookie->audioTrack_ref);
        delete pJniStorage;
    }
}

        之前保存在Java对象中的指针变量此时都要设置为零，然后删除引用

标签
#音视频
@OuYang
关注
Android Audio基础——AudioTrack音频控制（二十）
小旭的专栏
12-25 1819
AudioTrack 是用于播放音频数据的类，可以使用 set 方法设置音频数据，然后使用 start 来启动播放。而 pause 和 stop 则是用于控制播放过程的方法。不管 APP 使用什么播放音频文件，最终都是由 AudioTrack 将数据传递下去。
unity生成安卓应用的问题：在安卓中播放视频流的这个插件是vlc for unity，它在安卓中播放声音是通过调用安卓代码播放的声音，不走unity内部的音频组件...如何解决？
**My Coding Family**
02-24 1130
🏆本文收录于 《全栈 Bug 调优（实战版）》 专栏。专栏聚焦真实项目中的各类疑难 Bug，从成因剖析 → 排查路径 → 解决方案 → 预防优化全链路拆解，形成一套可复用、可沉淀的实战知识体系。无论你是初入职场的开发者，还是负责复杂项目的资深工程师，都可以在这里构建一套属于自己的「问题诊断与性能调优」方法论，助你稳步进阶、放大技术价值 。
Android AudioTrack创建流程
m0_51231887的博客
05-13 1410
AudioTrack是应用播放音频数据入口，通过该类应用可将解码后的音频数据播放出来。本篇主要简单介绍AudioTrack的创建流程。
【初学音频】Android的Audio系统之AudioTrack
TinyHorse的博客
08-22 5894
深入理解Android之AudioTrack的破解
Android Auido(2)-AudioTrack
Jimmy的专栏
04-10 2525
1 AudioTrack 用例介绍 AudioTr...
Android音视频开发-AudioTrack
赵航的博客
04-25 7432
AudioTrack是Android平台上的一个类，用于播放音频数据.它允许PCM音频缓冲区流式传输到音频接收器进行播放.创建AudioTrack对象：可以通过构造函数创建AudioTrack对象，需要指定音频流类型、采样率、音频通道配置和音频格式等参数。写入音频数据：可以使用write()方法将音频数据写入AudioTrack对象。写入的数据可以是PCM格式的原始音频数据，也可以是压缩格式的音频数据（如MP3、AAC等）。播放音频数据：在写入音频数据后，可以调用play()方法开始播放音频数据。
Anroid10 音频系统之数据传递
yang_0323的博客
03-14 1131
这和平时通过write系统调用往文件中写数据类似，但这种工作方式每次都需要把数据从用户提供的Buffer中拷贝到AudioTrack内部的Buffer中，这在一定程度上会使引入延时。MODE_STATIC：这种模式下，在play之前只需要把所有数据通过一次write调用传递到AudioTrack中的内部缓冲区，后续就不必再传递数据了。MODE_STREAM模式 会使用到环形缓存区来同步数据，一个生产数据，一个消费数据，这个时候使用环形缓冲区是最可靠的。环形缓冲区：初始R=0，W=0，buf长度为LEN。
深入浅出Android音频系统：从AudioTrack到音频输出通道的完整流程解析
weixin_30296405的博客
03-31 160
本文深入解析Android 10音频系统从AudioTrack创建到音频输出通道选择的完整流程，详细介绍了音频系统架构、数据传输机制及输出设备选择策略。通过实际代码示例和性能优化建议，帮助开发者掌握Android音频处理核心技术，提升应用音频性能。
Android音频调试实战：Audio log解析与设备连接状态追踪
最新发布
weixin_29230865的博客
03-31 162
本文深入解析Android音频调试中的Audio log分析技巧与设备连接状态追踪方法。通过实战案例展示如何识别设备类型编码、解析连接事件日志，并分享蓝牙音频专项排查与高级调试技巧，帮助开发者快速定位音频问题。
深入浅出Android音频系统：从AudioTrack到音频输出通道的完整流程剖析
cuda7parallel的博客
03-02 833
本文深入剖析了Android 10音频系统从应用层AudioTrack到硬件输出的完整流程。详细解读了AudioTrack初始化、AudioFlinger服务连接、AudioPolicyService路由决策以及PlaybackThread混音等核心环节，并探讨了低延迟音频与音频焦点管理等实战应用，为开发者解决音频延迟、设备切换等复杂问题提供底层原理支持。
ANDROID音频系统散记之一：A2dpAudioInterface && Android Audio System
martin的专栏
11-02 2732
http://www.rosoo.net/a/201202/15644.html   ANDROID音频系统散记之一：A2dpAudioInterface   本来有打算写写Android音频系统的，但是仔细研究了如下链接的三篇文章，果断中断了我的想法。毫不夸张来说，这是我看过的最好的阐述 Android音频系统的文章了，简练精辟，将音频系统各个方面的重要的脉络都描述出来了。有这三篇文
Android Framework 音频子系统（02）音频系统框架
wangdsh的博客
04-13 8138
​本章节主要关注➕ 以上思维导图下边 音频系统框架 部分 即可。主要是对音频系统框架 有一个基本的认识。1 Android 音频系统框架简介音频系统的 整个框架图如下所示：​针对这张框架图。AudioFlinger：接收多个APP的数据，合并下发；是策略的执行者，例如具体如何与音频设备通信，如何维护现有系统中的音频设备，以及多个音频流的混音如何处理等等都得由它来完 成。AudioPolicyService：决定选择哪个设备输出，接上耳机用耳机，接上蓝牙设备用蓝牙；
音：Android音频系统之音频框架
hunter
03-27 2486
Android音频系统之音频框架 2013年04月13日 11:58:12 林学森 阅读数：36305更多 https://blog.csdn.net/xuesen_lin/article/details/8796492#commentsedit 个人分类： Android专栏 所属专栏： Thinking In Android 1.1 音频框架 转载请注明，From LXS, ht...
Android10 音频系统之AudioRecord
yang_0323的博客
03-18 1614
mAudioRecord是audioFlinger->openRecord返回得到的recordHandle类型，recordHandle使用AudioFlinger::recordTrack初始化），实际上调用的是AudioFlinger::RecordThread::RecordTrack::start方法。3.调用AudioRecord的stop方法，AudioRecord就是RecordHandle对象，所以调用的stop方法就是RecordHandle的stop方法。
Android10 音频系统之音频输出通道
yang_0323的博客
01-08 2109
本篇文章讲解音频输出通道的选择
Android音频系统AudioTrack使用方法详解
weixin_42082222的博客
09-10 3909
1、Android AudioTrack简介 在android中播放声音可以用MediaPlayer和AudioTrack两种方案的，但是两种方案是有很大区别的，MediaPlayer可以播放多种格式的声音文件，例如MP3，AAC，WAV，OGG，MIDI等。而AudioTrack只能播放PCM数据流。 事实上，两种本质上是没啥区别的，MediaPlayer在播放音频时，在framework层...
Android10音频输出通道深度解析：从AudioTrack到设备路由
weixin_29230805的博客
02-25 292
本文深入解析了Android 10音频系统从应用层AudioTrack到硬件设备路由的完整链路。详细阐述了音频属性映射、AudioPolicyManager的策略决策逻辑、输出通道的匹配与建立过程，并结合音乐播放与通话等实战场景，揭示了音频自动路由与切换的内部机制，为开发者优化音频应用性能与避坑提供专业指导。
【Android FrameWork】第二十天：AudioTrack
u012739527的博客
12-01 1783
在Android音频播放体系中，AudioTrack是面向**原始PCM音频数据**的低延迟播放API，也是实时音频场景（如游戏音效、VOIP通话、实时音频处理）的核心组件。 与封装了解码逻辑的MediaPlayer不同，AudioTrack直接对接音频硬件，支持精细控制播放过程，但其使用需开发者自行处理PCM数据的生成、缓冲与传输。 本文将从定位差异、核心原理、API使用、底层交互及优化实践，全面解析AudioTrack的实现细节。
Android音频系统探究——从SoundPool到AudioHardware
tronteng的专栏
12-12 1946
对音频系统的探索起源于工作中遇到的一个bug。平时都是力求快速解决问题，不问原因。这次时间比较宽裕，正好借着解决问题的机会，把Android的音频系统了解一下。既然由bug引发，那就从bug开始说。 一. bug现象     Android的照相机在拍照的时候会播放一个按键音。最近的一个MID项目（基于RK3188，Android 4.2）中，测试部门反馈，拍照时按键音播放异常
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值