Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit b5323222 authored by Eric Laurent's avatar Eric Laurent
Browse files

add native IPlayer interface implementation 

Generalized the IPlayer implementation done for OpenSL ES
so that it can be used by other native audio players
Created two classes:
 - PlayerBase implementing the interfacin native AudioManager and
 IPlayer methods
 - TrackPlayerBase, a derived class specialized for AudioTrack.

Bug: 62027849
Test: verify regressions with OpenSL ES buffer queue player

Change-Id: If5ad21a3c1a243fba0b312001c5034102e6d6672
parent cc12f885

media/libaudioclient/Android.bp

+3 −0
Original line number Diff line number Diff line
@@ -22,6 +22,8 @@ cc_library_shared { 
        "IEffect.cpp",

        "IEffectClient.cpp",

        "ToneGenerator.cpp",

        "PlayerBase.cpp",

        "TrackPlayerBase.cpp",

    ],

    shared_libs: [

        "liblog",
@@ -30,6 +32,7 @@ cc_library_shared { 
        "libbinder",

        "libdl",

        "libaudioutils",

        "libaudiomanager",

    ],

    export_shared_lib_headers: ["libbinder"],

media/libaudioclient/PlayerBase.cpp

0 → 100644
+165 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2017 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#include <binder/IServiceManager.h>

#include <media/PlayerBase.h>



#define max(a, b) ((a) > (b) ? (a) : (b))

#define min(a, b) ((a) < (b) ? (a) : (b))



namespace android {



//--------------------------------------------------------------------------------------------------

PlayerBase::PlayerBase() : BnPlayer(),

        mPanMultiplierL(1.0f), mPanMultiplierR(1.0f),

        mVolumeMultiplierL(1.0f), mVolumeMultiplierR(1.0f),

        mPIId(PLAYER_PIID_INVALID), mLastReportedEvent(PLAYER_STATE_UNKNOWN)

{

    ALOGD("PlayerBase::PlayerBase()");

    // use checkService() to avoid blocking if audio service is not up yet

    sp<IBinder> binder = defaultServiceManager()->checkService(String16("audio"));

    if (binder == 0) {

        ALOGE("PlayerBase(): binding to audio service failed, service up?");

    } else {

        mAudioManager = interface_cast<IAudioManager>(binder);

    }

}





PlayerBase::~PlayerBase() {

    ALOGD("PlayerBase::~PlayerBase()");

    baseDestroy();

}



void PlayerBase::init(player_type_t playerType, audio_usage_t usage) {

    if (mAudioManager == 0) {

                ALOGE("AudioPlayer realize: no audio service, player will not be registered");

    } else {

        mPIId = mAudioManager->trackPlayer(playerType, usage, AUDIO_CONTENT_TYPE_UNKNOWN, this);

    }

}



void PlayerBase::baseDestroy() {

    serviceReleasePlayer();

    if (mAudioManager != 0) {

        mAudioManager.clear();

    }

}



//------------------------------------------------------------------------------

void PlayerBase::servicePlayerEvent(player_state_t event) {

    if (mAudioManager != 0) {

        // only report state change

        Mutex::Autolock _l(mPlayerStateLock);

        if (event != mLastReportedEvent

                && mPIId != PLAYER_PIID_INVALID) {

            mLastReportedEvent = event;

            mAudioManager->playerEvent(mPIId, event);

        }

    }

}



void PlayerBase::serviceReleasePlayer() {

    if (mAudioManager != 0

            && mPIId != PLAYER_PIID_INVALID) {

        mAudioManager->releasePlayer(mPIId);

    }

}



//FIXME temporary method while some AudioTrack state is outside of this class

void PlayerBase::reportEvent(player_state_t event) {

    servicePlayerEvent(event);

}



//------------------------------------------------------------------------------

// Implementation of IPlayer

void PlayerBase::start() {

    if (playerStart() == NO_ERROR) {

        ALOGD("PlayerBase::start() from IPlayer");

        servicePlayerEvent(PLAYER_STATE_STARTED);

    } else {

        ALOGD("PlayerBase::start() no AudioTrack to start from IPlayer");

    }

}



void PlayerBase::pause() {

    if (playerPause() == NO_ERROR) {

        ALOGD("PlayerBase::pause() from IPlayer");

        servicePlayerEvent(PLAYER_STATE_PAUSED);

    } else {

        ALOGD("PlayerBase::pause() no AudioTrack to pause from IPlayer");

    }

}





void PlayerBase::stop() {

    if (playerStop() == NO_ERROR) {

        ALOGD("PlayerBase::stop() from IPlayer");

        servicePlayerEvent(PLAYER_STATE_STOPPED);

    } else {

        ALOGD("PlayerBase::stop() no AudioTrack to stop from IPlayer");

    }

}



void PlayerBase::setVolume(float vol) {

    {

        Mutex::Autolock _l(mSettingsLock);

        mVolumeMultiplierL = vol;

        mVolumeMultiplierR = vol;

    }

    if (playerSetVolume() == NO_ERROR) {

        ALOGD("PlayerBase::setVolume() from IPlayer");

    } else {

        ALOGD("PlayerBase::setVolume() no AudioTrack for volume control from IPlayer");

    }

}



void PlayerBase::setPan(float pan) {

    {

        Mutex::Autolock _l(mSettingsLock);

        pan = min(max(-1.0f, pan), 1.0f);

        if (pan >= 0.0f) {

            mPanMultiplierL = 1.0f - pan;

            mPanMultiplierR = 1.0f;

        } else {

            mPanMultiplierL = 1.0f;

            mPanMultiplierR = 1.0f + pan;

        }

    }

    if (playerSetVolume() == NO_ERROR) {

        ALOGD("PlayerBase::setPan() from IPlayer");

    } else {

        ALOGD("PlayerBase::setPan() no AudioTrack for volume control from IPlayer");

    }

}



void PlayerBase::setStartDelayMs(int32_t delayMs __unused) {

    ALOGW("setStartDelay() is not supported");

}



void PlayerBase::applyVolumeShaper(

        const sp<VolumeShaper::Configuration>& configuration  __unused,

        const sp<VolumeShaper::Operation>& operation __unused) {

    ALOGW("applyVolumeShaper() is not supported");

}



status_t PlayerBase::onTransact(

    uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)

{

    return BnPlayer::onTransact(code, data, reply, flags);

}



} // namespace android

media/libaudioclient/TrackPlayerBase.cpp

0 → 100644
+121 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2017 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#include <media/TrackPlayerBase.h>



namespace android {



//--------------------------------------------------------------------------------------------------

TrackPlayerBase::TrackPlayerBase() : PlayerBase(),

        mPlayerVolumeL(1.0f), mPlayerVolumeR(1.0f)

{

    ALOGD("TrackPlayerBase::TrackPlayerBase()");

}





TrackPlayerBase::~TrackPlayerBase() {

    ALOGD("TrackPlayerBase::~TrackPlayerBase()");

    doDestroy();

}



void TrackPlayerBase::init(AudioTrack* pat, player_type_t playerType, audio_usage_t usage) {

    PlayerBase::init(playerType, usage);

    mAudioTrack = pat;

}



void TrackPlayerBase::destroy() {

    doDestroy();

    baseDestroy();

}



void TrackPlayerBase::doDestroy() {

    if (mAudioTrack != 0) {

        mAudioTrack->stop();

        // Note that there may still be another reference in post-unlock phase of SetPlayState

        mAudioTrack.clear();

    }

}



void TrackPlayerBase::setPlayerVolume(float vl, float vr) {

    {

        Mutex::Autolock _l(mSettingsLock);

        mPlayerVolumeL = vl;

        mPlayerVolumeR = vr;

    }

    doSetVolume();

}



//------------------------------------------------------------------------------

// Implementation of IPlayer

status_t TrackPlayerBase::playerStart() {

    status_t status = NO_INIT;

    if (mAudioTrack != 0) {

        status = mAudioTrack->start();

    }

    return status;

}



status_t TrackPlayerBase::playerPause() {

    status_t status = NO_INIT;

    if (mAudioTrack != 0) {

        mAudioTrack->pause();

        status = NO_ERROR;

    }

    return status;

}





status_t TrackPlayerBase::playerStop() {

    status_t status = NO_INIT;

    if (mAudioTrack != 0) {

        mAudioTrack->stop();

        status = NO_ERROR;

    }

    return status;

}



status_t TrackPlayerBase::playerSetVolume() {

    return doSetVolume();

}



status_t TrackPlayerBase::doSetVolume() {

    status_t status = NO_INIT;

    if (mAudioTrack != 0) {

        float tl = mPlayerVolumeL * mPanMultiplierL * mVolumeMultiplierL;

        float tr = mPlayerVolumeR * mPanMultiplierR * mVolumeMultiplierR;

        mAudioTrack->setVolume(tl, tr);

        status = NO_ERROR;

    }

    return status;

}





void TrackPlayerBase::applyVolumeShaper(

        const sp<VolumeShaper::Configuration>& configuration,

        const sp<VolumeShaper::Operation>& operation) {

    if (mAudioTrack != 0) {

        ALOGD("TrackPlayerBase::applyVolumeShaper() from IPlayer");

        VolumeShaper::Status status = mAudioTrack->applyVolumeShaper(configuration, operation);

        if (status < 0) { // a non-negative value is the volume shaper id.

            ALOGE("TrackPlayerBase::applyVolumeShaper() failed with status %d", status);

        }

    } else {

        ALOGD("TrackPlayerBase::applyVolumeShaper()"

                " no AudioTrack for volume control from IPlayer");

    }

}



} // namespace android

media/libaudioclient/include/media/PlayerBase.h

0 → 100644
+89 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2017 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#ifndef __ANDROID_PLAYER_BASE_H__

#define __ANDROID_PLAYER_BASE_H__



#include <audiomanager/IPlayer.h>

#include <audiomanager/AudioManager.h>

#include <audiomanager/IAudioManager.h>





namespace android {



class PlayerBase : public BnPlayer

{

public:

    explicit PlayerBase();

    virtual ~PlayerBase();



    virtual void destroy() = 0;



    //IPlayer implementation

    virtual void start();

    virtual void pause();

    virtual void stop();

    virtual void setVolume(float vol);

    virtual void setPan(float pan);

    virtual void setStartDelayMs(int32_t delayMs);

    virtual void applyVolumeShaper(

            const sp<VolumeShaper::Configuration>& configuration,

            const sp<VolumeShaper::Operation>& operation) override;



    virtual status_t onTransact(

                uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags);





            //FIXME temporary method while some player state is outside of this class

            void reportEvent(player_state_t event);



protected:



            void init(player_type_t playerType, audio_usage_t usage);

            void baseDestroy();



    //IPlayer methods handlers for derived classes

    virtual status_t playerStart()  { return NO_ERROR; }

    virtual status_t playerPause()  { return NO_ERROR; }

    virtual status_t playerStop()  { return NO_ERROR; }

    virtual status_t playerSetVolume()  { return NO_ERROR; }



    // mutex for IPlayer volume and pan, and player-specific volume

    Mutex mSettingsLock;



    // volume multipliers coming from the IPlayer volume and pan controls

    float mPanMultiplierL, mPanMultiplierR;

    float mVolumeMultiplierL, mVolumeMultiplierR;



private:

            // report events to AudioService

            void servicePlayerEvent(player_state_t event);

            void serviceReleasePlayer();



    // native interface to AudioService

    android::sp<android::IAudioManager> mAudioManager;



    // player interface ID, uniquely identifies the player in the system

    audio_unique_id_t mPIId;



    // Mutex for state reporting

    Mutex mPlayerStateLock;

    player_state_t mLastReportedEvent;

};



} // namespace android



#endif /* __ANDROID_PLAYER_BASE_H__ */

media/libaudioclient/include/media/TrackPlayerBase.h

0 → 100644
+62 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2017 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#ifndef __ANDROID_TRACK_PLAYER_BASE_H__

#define __ANDROID_TRACK_PLAYER_BASE_H__



#include <media/AudioTrack.h>

#include <media/PlayerBase.h>



namespace android {



class TrackPlayerBase : public PlayerBase

{

public:

    explicit TrackPlayerBase();

    virtual ~TrackPlayerBase();



            void init(AudioTrack* pat, player_type_t playerType, audio_usage_t usage);

    virtual void destroy();



    //IPlayer implementation

    virtual void applyVolumeShaper(

            const sp<VolumeShaper::Configuration>& configuration,

            const sp<VolumeShaper::Operation>& operation);



    //FIXME move to protected field, so far made public to minimize changes to AudioTrack logic

    sp<AudioTrack> mAudioTrack;



            void setPlayerVolume(float vl, float vr);



protected:



    //PlayerBase virtuals

    virtual status_t playerStart();

    virtual status_t playerPause();

    virtual status_t playerStop();

    virtual status_t playerSetVolume();



private:

            void doDestroy();

            status_t doSetVolume();



    // volume coming from the player volume API

    float mPlayerVolumeL, mPlayerVolumeR;

};



} // namespace android



#endif /* __ANDROID_TRACK_PLAYER_BASE_H__ */