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

Commit e00c4e93 authored by Ravi Kumar Alamanda's avatar Ravi Kumar Alamanda Committed by Gerrit - the friendly Code Review server
Browse files

hal: integrate ADM module 

HAL dynamically loads the ADM module and registers all the input
and output streams and also notifies all read and write operarations.

CRs-Fixed: 892056
Change-Id: Ie599f990c5d7224a6261e703c099fb98b5980c35
parent 57f1042e

hal/audio_hw.c

+68 −2
Original line number Diff line number Diff line 
/*

 * Copyright (c) 2013-2014, The Linux Foundation. All rights reserved.

 * Copyright (c) 2013-2015, The Linux Foundation. All rights reserved.

 * Not a Contribution.

 *

 * Copyright (C) 2013 The Android Open Source Project
@@ -1118,7 +1118,10 @@ int start_input_stream(struct stream_in *in) 
    }

    audio_extn_perf_lock_release();



    ALOGV("%s: pcm_prepare start", __func__);

    pcm_prepare(in->pcm);

    ALOGV("%s: exit", __func__);



    return ret;



error_open:
@@ -1600,8 +1603,14 @@ int start_output_stream(struct stream_out *out) 
            }

            break;

        }



        platform_set_stream_channel_map(adev->platform, out->channel_mask,

                                    out->pcm_device_id);



        ALOGV("%s: pcm_prepare start", __func__);

        if (pcm_is_ready(out->pcm))

            pcm_prepare(out->pcm);



    } else {

        platform_set_stream_channel_map(adev->platform, out->channel_mask,

                                    out->pcm_device_id);
@@ -1647,7 +1656,9 @@ int start_output_stream(struct stream_out *out) 
            audio_extn_check_and_set_dts_hpx_state(adev);

        }

    }



    ALOGV("%s: exit", __func__);



    return 0;

error_open:

    stop_output_stream(out);
@@ -1783,6 +1794,9 @@ static int out_standby(struct audio_stream *stream) 


    lock_output_stream(out);

    if (!out->standby) {

        if (adev->adm_deregister_stream)

            adev->adm_deregister_stream(adev->adm_data, out->handle);



        pthread_mutex_lock(&adev->lock);

        out->standby = true;

        if (!is_offload_usecase(out->usecase)) {
@@ -2123,6 +2137,8 @@ static ssize_t out_write(struct audio_stream_out *stream, const void *buffer, 
            out->standby = true;

            goto exit;

        }

        if (!is_offload_usecase(out->usecase) && adev->adm_register_output_stream)

            adev->adm_register_output_stream(adev->adm_data, out->handle, out->flags);

    }



    if (is_offload_usecase(out->usecase)) {
@@ -2169,15 +2185,24 @@ static ssize_t out_write(struct audio_stream_out *stream, const void *buffer, 
        if (out->pcm) {

            if (out->muted)

                memset((void *)buffer, 0, bytes);



            ALOGVV("%s: writing buffer (%d bytes) to pcm device", __func__, bytes);



            if (adev->adm_request_focus)

                adev->adm_request_focus(adev->adm_data, out->handle);



            if (out->usecase == USECASE_AUDIO_PLAYBACK_AFE_PROXY)

                ret = pcm_mmap_write(out->pcm, (void *)buffer, bytes);

            else

                ret = pcm_write(out->pcm, (void *)buffer, bytes);



            if (ret < 0)

                ret = -errno;

            else if (ret == 0)

                out->written += bytes / (out->config.channels * sizeof(short));



            if (adev->adm_abandon_focus)

                adev->adm_abandon_focus(adev->adm_data, out->handle);

        }

    }
@@ -2477,6 +2502,9 @@ static int in_standby(struct audio_stream *stream) 
    }



    if (!in->standby) {

        if (adev->adm_deregister_stream)

            adev->adm_deregister_stream(adev->adm_data, in->capture_handle);



        pthread_mutex_lock(&adev->lock);

        in->standby = true;

        if (in->pcm) {
@@ -2624,8 +2652,13 @@ static ssize_t in_read(struct audio_stream_in *stream, void *buffer, 
            }

        }

        in->standby = 0;

        if (adev->adm_register_input_stream)

            adev->adm_register_input_stream(adev->adm_data, in->capture_handle, in->flags);

    }



    if (adev->adm_request_focus)

        adev->adm_request_focus(adev->adm_data, in->capture_handle);



    if (in->pcm) {

        if (audio_extn_ssr_get_enabled() && (audio_extn_ssr_get_stream() == in))

            ret = audio_extn_ssr_read(stream, buffer, bytes);
@@ -2639,6 +2672,9 @@ static ssize_t in_read(struct audio_stream_in *stream, void *buffer, 
            ret = -errno;

    }



    if (adev->adm_abandon_focus)

        adev->adm_abandon_focus(adev->adm_data, in->capture_handle);



    /*

     * Instead of writing zeroes here, we could trust the hardware

     * to always provide zeroes when muted.
@@ -3398,7 +3434,7 @@ static int adev_open_input_stream(struct audio_hw_device *dev, 
                                  audio_devices_t devices,

                                  struct audio_config *config,

                                  struct audio_stream_in **stream_in,

                                  audio_input_flags_t flags __unused,

                                  audio_input_flags_t flags,

                                  const char *address __unused,

                                  audio_source_t source)

{
@@ -3448,6 +3484,7 @@ static int adev_open_input_stream(struct audio_hw_device *dev, 
    in->standby = 1;

    in->channel_mask = config->channel_mask;

    in->capture_handle = handle;

    in->flags = flags;



    /* Update config params with the requested sample rate and channels */

    in->usecase = USECASE_AUDIO_RECORD;
@@ -3601,10 +3638,13 @@ static int adev_close(hw_device_t *device) 
        audio_route_free(adev->audio_route);

        free(adev->snd_dev_ref_cnt);

        platform_deinit(adev->platform);

        if (adev->adm_deinit)

            adev->adm_deinit(adev->adm_data);

        free(device);

        adev = NULL;

    }

    pthread_mutex_unlock(&adev_init_lock);



    return 0;

}
@@ -3744,6 +3784,29 @@ static int adev_open(const hw_module_t *module, const char *name, 
        }

    }



    if (access(ADM_LIBRARY_PATH, R_OK) == 0) {

        adev->adm_lib = dlopen(ADM_LIBRARY_PATH, RTLD_NOW);

        if (adev->adm_lib == NULL) {

            ALOGE("%s: DLOPEN failed for %s", __func__, ADM_LIBRARY_PATH);

        } else {

            ALOGV("%s: DLOPEN successful for %s", __func__, ADM_LIBRARY_PATH);

            adev->adm_init = (adm_init_t)

                                    dlsym(adev->adm_lib, "adm_init");

            adev->adm_deinit = (adm_deinit_t)

                                    dlsym(adev->adm_lib, "adm_deinit");

            adev->adm_register_input_stream = (adm_register_input_stream_t)

                                    dlsym(adev->adm_lib, "adm_register_input_stream");

            adev->adm_register_output_stream = (adm_register_output_stream_t)

                                    dlsym(adev->adm_lib, "adm_register_output_stream");

            adev->adm_deregister_stream = (adm_deregister_stream_t)

                                    dlsym(adev->adm_lib, "adm_deregister_stream");

            adev->adm_request_focus = (adm_request_focus_t)

                                    dlsym(adev->adm_lib, "adm_request_focus");

            adev->adm_abandon_focus = (adm_abandon_focus_t)

                                    dlsym(adev->adm_lib, "adm_abandon_focus");

        }

    }



    adev->bt_wb_speech_enabled = false;



    audio_extn_ds2_enable(adev);
@@ -3774,6 +3837,9 @@ static int adev_open(const hw_module_t *module, const char *name, 


    pthread_mutex_unlock(&adev_init_lock);



    if (adev->adm_init)

        adev->adm_data = adev->adm_init();



    ALOGV("%s: exit", __func__);

    return 0;

}

hal/audio_hw.h

+20 −0
Original line number Diff line number Diff line
@@ -50,6 +50,7 @@ 


#define VISUALIZER_LIBRARY_PATH "/system/lib/soundfx/libqcomvisualizer.so"

#define OFFLOAD_EFFECTS_BUNDLE_LIBRARY_PATH "/system/lib/soundfx/libqcompostprocbundle.so"

#define ADM_LIBRARY_PATH "/system/vendor/lib/libadm.so"



/* Flags used to initialize acdb_settings variable that goes to ACDB library */

#define NONE_FLAG            0x00000000
@@ -240,6 +241,7 @@ struct stream_in { 
    bool enable_ns;

    audio_format_t format;

    audio_io_handle_t capture_handle;

    audio_input_flags_t flags;

    bool is_st_session;

    bool is_st_session_active;
@@ -292,6 +294,14 @@ struct streams_output_cfg { 
    struct stream_app_type_cfg app_type_cfg;

};



typedef void* (*adm_init_t)();

typedef void (*adm_deinit_t)(void *);

typedef void (*adm_register_output_stream_t)(void *, audio_io_handle_t, audio_output_flags_t);

typedef void (*adm_register_input_stream_t)(void *, audio_io_handle_t, audio_input_flags_t);

typedef void (*adm_deregister_stream_t)(void *, audio_io_handle_t);

typedef void (*adm_request_focus_t)(void *, audio_io_handle_t);

typedef void (*adm_abandon_focus_t)(void *, audio_io_handle_t);



struct audio_device {

    struct audio_hw_device device;

    pthread_mutex_t lock; /* see note below on mutex acquisition order */
@@ -329,6 +339,16 @@ struct audio_device { 


    struct sound_card_status snd_card_status;

    int (*offload_effects_set_hpx_state)(bool);



    void *adm_data;

    void *adm_lib;

    adm_init_t adm_init;

    adm_deinit_t adm_deinit;

    adm_register_input_stream_t adm_register_input_stream;

    adm_register_output_stream_t adm_register_output_stream;

    adm_deregister_stream_t adm_deregister_stream;

    adm_request_focus_t adm_request_focus;

    adm_abandon_focus_t adm_abandon_focus;

};



int select_devices(struct audio_device *adev,