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

Commit 9cd89817 authored by Ytai Ben-Tsvi's avatar Ytai Ben-Tsvi
Browse files

Convert IEffect and IEffectClient to AIDL 

This change replaces the manually-parceled IEffect and IEffectClient
with AIDL definitions.

In addition, this includes a small library that facilitates shared
memory regions over AIDL.

Bug: 160253486
Test: Ran effects-related CTS tests. Manual verification of basic
      audio functionality on Sargo.

Change-Id: I5a9c5f2f24c10072ad5067acc71aa30581af41c1
parent 37934a22

media/libaudioclient/Android.bp

+24 −5
Original line number Diff line number Diff line
@@ -77,8 +77,6 @@ cc_library_shared { 
        "IAudioPolicyService.cpp",

        "IAudioPolicyServiceClient.cpp",

        "IAudioTrack.cpp",

        "IEffect.cpp",

        "IEffectClient.cpp",

        "ToneGenerator.cpp",

        "PlayerBase.cpp",

        "RecordingActivityTracker.cpp",
@@ -99,6 +97,7 @@ cc_library_shared { 
        "libmediautils",

        "libnblog",

        "libprocessgroup",

        "libshmemcompat",

        "libutils",

        "libvibrator",

    ],
@@ -108,7 +107,8 @@ cc_library_shared { 
        "frameworks/av/media/libnbaio/include_mono/",

    ],

    local_include_dirs: [

        "include/media", "aidl"

        "include/media",

        "aidl",

    ],

    header_libs: [

        "libaudioclient_headers",
@@ -116,10 +116,16 @@ cc_library_shared { 
        "libmedia_headers",

    ],

    export_header_lib_headers: ["libaudioclient_headers"],

    export_static_lib_headers: [

        "effect-aidl-cpp",

        "shared-file-region-aidl-cpp",

    ],



    // for memory heap analysis

    static_libs: [

        "effect-aidl-cpp",

        // for memory heap analysis

        "libc_malloc_debug_backtrace",

        "shared-file-region-aidl-cpp",

    ],

    cflags: [

        "-Wall",
@@ -170,3 +176,16 @@ aidl_interface { 
        "aidl/android/media/ICaptureStateListener.aidl",

    ],

}



aidl_interface {

    name: "effect-aidl",

    unstable: true,

    local_include_dir: "aidl",

    srcs: [

        "aidl/android/media/IEffect.aidl",

        "aidl/android/media/IEffectClient.aidl",

    ],

    imports: [

        "shared-file-region-aidl",

    ],

}

media/libaudioclient/AudioEffect.cpp

+89 −27
Original line number Diff line number Diff line
@@ -23,15 +23,27 @@ 
#include <sys/types.h>

#include <limits.h>



#include <private/media/AudioEffectShared.h>

#include <binder/IPCThreadState.h>

#include <media/AudioEffect.h>



#include <media/ShmemCompat.h>

#include <private/media/AudioEffectShared.h>

#include <utils/Log.h>

#include <binder/IPCThreadState.h>



namespace android {



using binder::Status;



namespace android {

namespace {



// Copy from a raw pointer + size into a vector of bytes.

void appendToBuffer(const void* data,

                    size_t size,

                    std::vector<uint8_t>* buffer) {

    const uint8_t* p = reinterpret_cast<const uint8_t*>(data);

    buffer->insert(buffer->end(), p, p + size);

}



}  // namespace



// ---------------------------------------------------------------------------
@@ -50,7 +62,7 @@ status_t AudioEffect::set(const effect_uuid_t *type, 
                const AudioDeviceTypeAddr& device,

                bool probe)

{

    sp<IEffect> iEffect;

    sp<media::IEffect> iEffect;

    sp<IMemory> cblk;

    int enabled;
@@ -112,8 +124,10 @@ status_t AudioEffect::set(const effect_uuid_t *type, 


    mEnabled = (volatile int32_t)enabled;



    cblk = iEffect->getCblk();

    if (cblk == 0) {

    if (media::SharedFileRegion shmem;

            !iEffect->getCblk(&shmem).isOk()

            || !convertSharedFileRegionToIMemory(shmem, &cblk)

            || cblk == 0) {

        mStatus = NO_INIT;

        ALOGE("Could not get control block");

        return mStatus;
@@ -216,15 +230,19 @@ status_t AudioEffect::setEnabled(bool enabled) 
    }



    status_t status = NO_ERROR;



    AutoMutex lock(mLock);

    if (enabled != mEnabled) {

        Status bs;



        if (enabled) {

            ALOGV("enable %p", this);

            status = mIEffect->enable();

            bs = mIEffect->enable(&status);

        } else {

            ALOGV("disable %p", this);

            status = mIEffect->disable();

            bs = mIEffect->disable(&status);

        }

        if (!bs.isOk()) {

            status = bs.transactionError();

        }

        if (status == NO_ERROR) {

            mEnabled = enabled;
@@ -257,7 +275,20 @@ status_t AudioEffect::command(uint32_t cmdCode, 
        mLock.lock();

    }



    status_t status = mIEffect->command(cmdCode, cmdSize, cmdData, replySize, replyData);

    std::vector<uint8_t> data;

    appendToBuffer(cmdData, cmdSize, &data);



    status_t status;

    std::vector<uint8_t> response;



    Status bs = mIEffect->command(cmdCode, data, *replySize, &response, &status);

    if (!bs.isOk()) {

        status = bs.transactionError();

    }

    if (status == NO_ERROR) {

        memcpy(replyData, response.data(), response.size());

        *replySize = response.size();

    }



    if (cmdCode == EFFECT_CMD_ENABLE || cmdCode == EFFECT_CMD_DISABLE) {

        if (status == NO_ERROR) {
@@ -272,7 +303,6 @@ status_t AudioEffect::command(uint32_t cmdCode, 
    return status;

}





status_t AudioEffect::setParameter(effect_param_t *param)

{

    if (mProbe) {
@@ -286,14 +316,27 @@ status_t AudioEffect::setParameter(effect_param_t *param) 
        return BAD_VALUE;

    }



    uint32_t size = sizeof(int);

    uint32_t psize = ((param->psize - 1) / sizeof(int) + 1) * sizeof(int) + param->vsize;



    ALOGV("setParameter: param: %d, param2: %d", *(int *)param->data,

            (param->psize == 8) ? *((int *)param->data + 1): -1);



    return mIEffect->command(EFFECT_CMD_SET_PARAM, sizeof (effect_param_t) + psize, param, &size,

            &param->status);

    std::vector<uint8_t> cmd;

    appendToBuffer(param, sizeof(effect_param_t) + psize, &cmd);

    std::vector<uint8_t> response;

    status_t status;

    Status bs = mIEffect->command(EFFECT_CMD_SET_PARAM,

                                  cmd,

                                  sizeof(int),

                                  &response,

                                  &status);

    if (!bs.isOk()) {

        status = bs.transactionError();

        return status;

    }

    assert(response.size() == sizeof(int));

    memcpy(&param->status, response.data(), response.size());

    return status;

}



status_t AudioEffect::setParameterDeferred(effect_param_t *param)
@@ -338,8 +381,18 @@ status_t AudioEffect::setParameterCommit() 
    if (mCblk->clientIndex == 0) {

        return INVALID_OPERATION;

    }

    uint32_t size = 0;

    return mIEffect->command(EFFECT_CMD_SET_PARAM_COMMIT, 0, NULL, &size, NULL);

    std::vector<uint8_t> cmd;

    std::vector<uint8_t> response;

    status_t status;

    Status bs = mIEffect->command(EFFECT_CMD_SET_PARAM_COMMIT,

                                  cmd,

                                  0,

                                  &response,

                                  &status);

    if (!bs.isOk()) {

        status = bs.transactionError();

    }

    return status;

}



status_t AudioEffect::getParameter(effect_param_t *param)
@@ -361,8 +414,18 @@ status_t AudioEffect::getParameter(effect_param_t *param) 
    uint32_t psize = sizeof(effect_param_t) + ((param->psize - 1) / sizeof(int) + 1) * sizeof(int) +

            param->vsize;



    return mIEffect->command(EFFECT_CMD_GET_PARAM, sizeof(effect_param_t) + param->psize, param,

            &psize, param);

    status_t status;

    std::vector<uint8_t> cmd;

    std::vector<uint8_t> response;

    appendToBuffer(param, sizeof(effect_param_t) + param->psize, &cmd);



    Status bs = mIEffect->command(EFFECT_CMD_GET_PARAM, cmd, psize, &response, &status);

    if (!bs.isOk()) {

        status = bs.transactionError();

        return status;

    }

    memcpy(param, response.data(), response.size());

    return status;

}
@@ -410,19 +473,18 @@ void AudioEffect::enableStatusChanged(bool enabled) 
    }

}



void AudioEffect::commandExecuted(uint32_t cmdCode,

                                  uint32_t cmdSize __unused,

                                  void *cmdData,

                                  uint32_t replySize __unused,

                                  void *replyData)

void AudioEffect::commandExecuted(int32_t cmdCode,

                                  const std::vector<uint8_t>& cmdData,

                                  const std::vector<uint8_t>& replyData)

{

    if (cmdData == NULL || replyData == NULL) {

    if (cmdData.empty() || replyData.empty()) {

        return;

    }



    if (mCbf != NULL && cmdCode == EFFECT_CMD_SET_PARAM) {

        effect_param_t *cmd = (effect_param_t *)cmdData;

        cmd->status = *(int32_t *)replyData;

        std::vector<uint8_t> cmdDataCopy(cmdData);

        effect_param_t* cmd = reinterpret_cast<effect_param_t *>(cmdDataCopy.data());

        cmd->status = *reinterpret_cast<const int32_t *>(replyData.data());

        mCbf(EVENT_PARAMETER_CHANGED, mUserData, cmd);

    }

}

media/libaudioclient/IAudioFlinger.cpp

+8 −7
Original line number Diff line number Diff line
@@ -653,9 +653,9 @@ public: 
        return NO_ERROR;

    }



    virtual sp<IEffect> createEffect(

    virtual sp<media::IEffect> createEffect(

                                    effect_descriptor_t *pDesc,

                                    const sp<IEffectClient>& client,

                                    const sp<media::IEffectClient>& client,

                                    int32_t priority,

                                    audio_io_handle_t output,

                                    audio_session_t sessionId,
@@ -668,7 +668,7 @@ public: 
                                    int *enabled)

    {

        Parcel data, reply;

        sp<IEffect> effect;

        sp<media::IEffect> effect;

        if (pDesc == NULL) {

            if (status != NULL) {

                *status = BAD_VALUE;
@@ -705,7 +705,7 @@ public: 
            if (enabled != NULL) {

                *enabled = tmp;

            }

            effect = interface_cast<IEffect>(reply.readStrongBinder());

            effect = interface_cast<media::IEffect>(reply.readStrongBinder());

            reply.read(pDesc, sizeof(effect_descriptor_t));

        }

        if (status != NULL) {
@@ -1386,7 +1386,8 @@ status_t BnAudioFlinger::onTransact( 
            if (data.read(&desc, sizeof(effect_descriptor_t)) != NO_ERROR) {

                ALOGE("b/23905951");

            }

            sp<IEffectClient> client = interface_cast<IEffectClient>(data.readStrongBinder());

            sp<media::IEffectClient> client =

                    interface_cast<media::IEffectClient>(data.readStrongBinder());

            int32_t priority = data.readInt32();

            audio_io_handle_t output = (audio_io_handle_t) data.readInt32();

            audio_session_t sessionId = (audio_session_t) data.readInt32();
@@ -1402,8 +1403,8 @@ status_t BnAudioFlinger::onTransact( 
            int id = 0;

            int enabled = 0;



            sp<IEffect> effect = createEffect(&desc, client, priority, output, sessionId, device,

                    opPackageName, pid, probe, &status, &id, &enabled);

            sp<media::IEffect> effect = createEffect(&desc, client, priority, output, sessionId,

                    device, opPackageName, pid, probe, &status, &id, &enabled);

            reply->writeInt32(status);

            reply->writeInt32(id);

            reply->writeInt32(enabled);

media/libaudioclient/IEffect.cpp

deleted100644 → 0
+0 −229
Original line number Diff line number Diff line 
/*

**

** Copyright 2010, 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.

*/



//#define LOG_NDEBUG 0

#define LOG_TAG "IEffect"

#include <utils/Log.h>

#include <stdint.h>

#include <sys/types.h>

#include <binder/Parcel.h>

#include <media/IEffect.h>



namespace android {



// Maximum command/reply size expected

#define EFFECT_PARAM_SIZE_MAX       65536



enum {

    ENABLE = IBinder::FIRST_CALL_TRANSACTION,

    DISABLE,

    COMMAND,

    DISCONNECT,

    GET_CBLK

};



class BpEffect: public BpInterface<IEffect>

{

public:

    explicit BpEffect(const sp<IBinder>& impl)

        : BpInterface<IEffect>(impl)

    {

    }



    status_t enable()

    {

        ALOGV("enable");

        Parcel data, reply;

        data.writeInterfaceToken(IEffect::getInterfaceDescriptor());

        remote()->transact(ENABLE, data, &reply);

        return reply.readInt32();

    }



    status_t disable()

    {

        ALOGV("disable");

        Parcel data, reply;

        data.writeInterfaceToken(IEffect::getInterfaceDescriptor());

        remote()->transact(DISABLE, data, &reply);

        return reply.readInt32();

    }



    status_t command(uint32_t cmdCode,

                     uint32_t cmdSize,

                     void *pCmdData,

                     uint32_t *pReplySize,

                     void *pReplyData)

    {

        ALOGV("command");

        Parcel data, reply;

        data.writeInterfaceToken(IEffect::getInterfaceDescriptor());

        data.writeInt32(cmdCode);

        int size = cmdSize;

        if (pCmdData == NULL) {

            size = 0;

        }

        data.writeInt32(size);

        if (size) {

            data.write(pCmdData, size);

        }

        if (pReplySize == NULL) {

            size = 0;

        } else {

            size = *pReplySize;

        }

        data.writeInt32(size);



        status_t status = remote()->transact(COMMAND, data, &reply);

        if (status == NO_ERROR) {

            status = reply.readInt32();

        }

        if (status != NO_ERROR) {

            if (pReplySize != NULL)

                *pReplySize = 0;

            return status;

        }



        size = reply.readInt32();

        if (size != 0 && pReplyData != NULL && pReplySize != NULL) {

            reply.read(pReplyData, size);

            *pReplySize = size;

        }

        return status;

    }



    void disconnect()

    {

        ALOGV("disconnect");

        Parcel data, reply;

        data.writeInterfaceToken(IEffect::getInterfaceDescriptor());

        remote()->transact(DISCONNECT, data, &reply);

        return;

    }



    virtual sp<IMemory> getCblk() const

    {

        Parcel data, reply;

        sp<IMemory> cblk;

        data.writeInterfaceToken(IEffect::getInterfaceDescriptor());

        status_t status = remote()->transact(GET_CBLK, data, &reply);

        if (status == NO_ERROR) {

            cblk = interface_cast<IMemory>(reply.readStrongBinder());

            if (cblk != 0 && cblk->unsecurePointer() == NULL) {

                cblk.clear();

            }

        }

        return cblk;

    }

 };



IMPLEMENT_META_INTERFACE(Effect, "android.media.IEffect");



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



status_t BnEffect::onTransact(

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

{

    switch (code) {

        case ENABLE: {

            ALOGV("ENABLE");

            CHECK_INTERFACE(IEffect, data, reply);

            reply->writeInt32(enable());

            return NO_ERROR;

        } break;



        case DISABLE: {

            ALOGV("DISABLE");

            CHECK_INTERFACE(IEffect, data, reply);

            reply->writeInt32(disable());

            return NO_ERROR;

        } break;



        case COMMAND: {

            ALOGV("COMMAND");

            CHECK_INTERFACE(IEffect, data, reply);

            uint32_t cmdCode = data.readInt32();

            uint32_t cmdSize = data.readInt32();

            char *cmd = NULL;

            if (cmdSize) {

                if (cmdSize > EFFECT_PARAM_SIZE_MAX) {

                    reply->writeInt32(NO_MEMORY);

                    return NO_ERROR;

                }

                cmd = (char *)calloc(cmdSize, 1);

                if (cmd == NULL) {

                    reply->writeInt32(NO_MEMORY);

                    return NO_ERROR;

                }

                data.read(cmd, cmdSize);

            }

            uint32_t replySize = data.readInt32();

            uint32_t replySz = replySize;

            char *resp = NULL;

            if (replySize) {

                if (replySize > EFFECT_PARAM_SIZE_MAX) {

                    free(cmd);

                    reply->writeInt32(NO_MEMORY);

                    return NO_ERROR;

                }

                resp = (char *)calloc(replySize, 1);

                if (resp == NULL) {

                    free(cmd);

                    reply->writeInt32(NO_MEMORY);

                    return NO_ERROR;

                }

            }

            status_t status = command(cmdCode, cmdSize, cmd, &replySz, resp);

            reply->writeInt32(status);

            if (status == NO_ERROR) {

                if (replySz < replySize) {

                    replySize = replySz;

                }

                reply->writeInt32(replySize);

                if (replySize) {

                    reply->write(resp, replySize);

                }

            }

            if (cmd) {

                free(cmd);

            }

            if (resp) {

                free(resp);

            }

            return NO_ERROR;

        } break;



        case DISCONNECT: {

            ALOGV("DISCONNECT");

            CHECK_INTERFACE(IEffect, data, reply);

            disconnect();

            return NO_ERROR;

        } break;



        case GET_CBLK: {

            CHECK_INTERFACE(IEffect, data, reply);

            reply->writeStrongBinder(IInterface::asBinder(getCblk()));

            return NO_ERROR;

        } break;



        default:

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

    }

}



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



} // namespace android

media/libaudioclient/IEffectClient.cpp

deleted100644 → 0
+0 −144
Original line number Diff line number Diff line 
/*

**

** Copyright 2010, 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.

*/



//#define LOG_NDEBUG 0

#define LOG_TAG "IEffectClient"

#include <utils/Log.h>

#include <stdint.h>

#include <sys/types.h>

#include <media/IEffectClient.h>



namespace android {



enum {

    CONTROL_STATUS_CHANGED = IBinder::FIRST_CALL_TRANSACTION,

    ENABLE_STATUS_CHANGED,

    COMMAND_EXECUTED

};



class BpEffectClient: public BpInterface<IEffectClient>

{

public:

    explicit BpEffectClient(const sp<IBinder>& impl)

        : BpInterface<IEffectClient>(impl)

    {

    }



    void controlStatusChanged(bool controlGranted)

    {

        ALOGV("controlStatusChanged");

        Parcel data, reply;

        data.writeInterfaceToken(IEffectClient::getInterfaceDescriptor());

        data.writeInt32((uint32_t)controlGranted);

        remote()->transact(CONTROL_STATUS_CHANGED, data, &reply, IBinder::FLAG_ONEWAY);

    }



    void enableStatusChanged(bool enabled)

    {

        ALOGV("enableStatusChanged");

        Parcel data, reply;

        data.writeInterfaceToken(IEffectClient::getInterfaceDescriptor());

        data.writeInt32((uint32_t)enabled);

        remote()->transact(ENABLE_STATUS_CHANGED, data, &reply, IBinder::FLAG_ONEWAY);

    }



    void commandExecuted(uint32_t cmdCode,

                         uint32_t cmdSize,

                         void *pCmdData,

                         uint32_t replySize,

                         void *pReplyData)

    {

        ALOGV("commandExecuted");

        Parcel data, reply;

        data.writeInterfaceToken(IEffectClient::getInterfaceDescriptor());

        data.writeInt32(cmdCode);

        int size = cmdSize;

        if (pCmdData == NULL) {

            size = 0;

        }

        data.writeInt32(size);

        if (size) {

            data.write(pCmdData, size);

        }

        size = replySize;

        if (pReplyData == NULL) {

            size = 0;

        }

        data.writeInt32(size);

        if (size) {

            data.write(pReplyData, size);

        }

        remote()->transact(COMMAND_EXECUTED, data, &reply, IBinder::FLAG_ONEWAY);

    }



};



IMPLEMENT_META_INTERFACE(EffectClient, "android.media.IEffectClient");



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



status_t BnEffectClient::onTransact(

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

{

    switch (code) {

        case CONTROL_STATUS_CHANGED: {

            ALOGV("CONTROL_STATUS_CHANGED");

            CHECK_INTERFACE(IEffectClient, data, reply);

            bool hasControl = (bool)data.readInt32();

            controlStatusChanged(hasControl);

            return NO_ERROR;

        } break;

        case ENABLE_STATUS_CHANGED: {

            ALOGV("ENABLE_STATUS_CHANGED");

            CHECK_INTERFACE(IEffectClient, data, reply);

            bool enabled = (bool)data.readInt32();

            enableStatusChanged(enabled);

            return NO_ERROR;

        } break;

        case COMMAND_EXECUTED: {

            ALOGV("COMMAND_EXECUTED");

            CHECK_INTERFACE(IEffectClient, data, reply);

            uint32_t cmdCode = data.readInt32();

            uint32_t cmdSize = data.readInt32();

            char *cmd = NULL;

            if (cmdSize) {

                cmd = (char *)malloc(cmdSize);

                data.read(cmd, cmdSize);

            }

            uint32_t replySize = data.readInt32();

            char *resp = NULL;

            if (replySize) {

                resp = (char *)malloc(replySize);

                data.read(resp, replySize);

            }

            commandExecuted(cmdCode, cmdSize, cmd, replySize, resp);

            if (cmd) {

                free(cmd);

            }

            if (resp) {

                free(resp);

            }

            return NO_ERROR;

        } break;

        default:

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

    }

}



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



} // namespace android