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

Commit 9ebc9fcb authored by millerliang's avatar millerliang Committed by Automerger Merge Worker
Browse files

hal: Fix AudioRecord and AudioTrack timestamps incorrect am: 680f5607 

Change-Id: I1d8e8c53bfa0653457062f19bbe7f28f2442db33
parents 129fa9a4 680f5607

hal/audio_hw.c

+4 −3
Original line number Diff line number Diff line
@@ -3286,7 +3286,7 @@ static uint32_t out_get_latency(const struct audio_stream_out *stream) 
        // return a smaller number

        period_ms = (out->af_period_multiplier * out->config.period_size *

                     1000) / (out->config.rate);

        hw_delay = platform_render_latency(out->usecase)/1000;

        hw_delay = platform_render_latency(out)/1000;

        return period_ms + hw_delay;

    }
@@ -3770,7 +3770,7 @@ static int out_get_presentation_position(const struct audio_stream_out *stream, 
                // This adjustment accounts for buffering after app processor.

                // It is based on estimated DSP latency per use case, rather than exact.

                signed_frames -=

                    (platform_render_latency(out->usecase) * out->sample_rate / 1000000LL);

                    (platform_render_latency(out) * out->sample_rate / 1000000LL);



                // Adjustment accounts for A2DP encoder latency with non-offload usecases

                // Note: Encoder latency is returned in ms, while platform_render_latency in us.
@@ -4490,7 +4490,8 @@ static int in_get_capture_position(const struct audio_stream_in *stream, 
        unsigned int avail;

        if (pcm_get_htimestamp(in->pcm, &avail, &timestamp) == 0) {

            *frames = in->frames_read + avail;

            *time = timestamp.tv_sec * 1000000000LL + timestamp.tv_nsec;

            *time = timestamp.tv_sec * 1000000000LL + timestamp.tv_nsec

                    - platform_capture_latency(in) * 1000LL;

            ret = 0;

        }

    }

hal/msm8916/platform.c

+96 −5
Original line number Diff line number Diff line
@@ -554,6 +554,24 @@ static struct name_to_index usecase_name_index[AUDIO_USECASE_MAX] = { 
#define DEEP_BUFFER_PLATFORM_DELAY (29*1000LL)

#define LOW_LATENCY_PLATFORM_DELAY (13*1000LL)



static int audio_usecase_delay_ms[AUDIO_USECASE_MAX] = {0};



static int audio_source_delay_ms[AUDIO_SOURCE_CNT] = {0};



static struct name_to_index audio_source_index[AUDIO_SOURCE_CNT] = {

    {TO_NAME_INDEX(AUDIO_SOURCE_DEFAULT)},

    {TO_NAME_INDEX(AUDIO_SOURCE_MIC)},

    {TO_NAME_INDEX(AUDIO_SOURCE_VOICE_UPLINK)},

    {TO_NAME_INDEX(AUDIO_SOURCE_VOICE_DOWNLINK)},

    {TO_NAME_INDEX(AUDIO_SOURCE_VOICE_CALL)},

    {TO_NAME_INDEX(AUDIO_SOURCE_CAMCORDER)},

    {TO_NAME_INDEX(AUDIO_SOURCE_VOICE_RECOGNITION)},

    {TO_NAME_INDEX(AUDIO_SOURCE_VOICE_COMMUNICATION)},

    {TO_NAME_INDEX(AUDIO_SOURCE_REMOTE_SUBMIX)},

    {TO_NAME_INDEX(AUDIO_SOURCE_UNPROCESSED)},

    {TO_NAME_INDEX(AUDIO_SOURCE_VOICE_PERFORMANCE)},

};



static void query_platform(const char *snd_card_name,

                                      char *mixer_xml_path)

{
@@ -1453,6 +1471,11 @@ int platform_get_usecase_index(const char *usecase_name) 
    return find_index(usecase_name_index, AUDIO_USECASE_MAX, usecase_name);

}



int platform_get_audio_source_index(const char *audio_source_name)

{

    return find_index(audio_source_index, AUDIO_SOURCE_CNT, audio_source_name);

}



int platform_get_effect_config_data(snd_device_t snd_device,

                                      struct audio_effect_config *effect_config,

                                      effect_type_t effect_type)
@@ -2559,17 +2582,85 @@ done: 
    return ret;

}



void platform_set_audio_source_delay(audio_source_t audio_source, int delay_ms)

{

    if ((audio_source < AUDIO_SOURCE_DEFAULT) ||

           (audio_source > AUDIO_SOURCE_MAX)) {

        ALOGE("%s: Invalid audio_source = %d", __func__, audio_source);

        return;

    }



    audio_source_delay_ms[audio_source] = delay_ms;

}



/* Delay in Us */

int64_t platform_get_audio_source_delay(audio_source_t audio_source)

{

    if ((audio_source < AUDIO_SOURCE_DEFAULT) ||

            (audio_source > AUDIO_SOURCE_MAX)) {

        ALOGE("%s: Invalid audio_source = %d", __func__, audio_source);

        return 0;

    }



    return 1000LL * audio_source_delay_ms[audio_source];

}



void platform_set_audio_usecase_delay(audio_usecase_t usecase, int delay_ms)

{

    if ((usecase <= USECASE_INVALID) || (usecase >= AUDIO_USECASE_MAX)) {

        ALOGE("%s: invalid usecase case idx %d", __func__, usecase);

        return;

    }



    audio_usecase_delay_ms[usecase] = delay_ms;

}



/* Delay in Us */

int64_t platform_get_audio_usecase_delay(audio_usecase_t usecase)

{

    if ((usecase <= USECASE_INVALID) || (usecase >= AUDIO_USECASE_MAX)) {

        ALOGE("%s: invalid usecase case idx %d", __func__, usecase);

        return 0;

    }



    return 1000LL *  audio_usecase_delay_ms[usecase] ;

}



/* Delay in Us */

int64_t platform_render_latency(audio_usecase_t usecase)

int64_t platform_render_latency(struct stream_out *out)

{

    switch (usecase) {

    int64_t delay = 0LL;



    if (!out)

        return delay;



    switch (out->usecase) {

        case USECASE_AUDIO_PLAYBACK_DEEP_BUFFER:

            return DEEP_BUFFER_PLATFORM_DELAY;

            delay = DEEP_BUFFER_PLATFORM_DELAY;

            break;

        case USECASE_AUDIO_PLAYBACK_LOW_LATENCY:

            return LOW_LATENCY_PLATFORM_DELAY;

            delay = LOW_LATENCY_PLATFORM_DELAY;

            break;

        default:

            return 0;

            break;

    }



/* out->usecase could be used to add delay time if it's necessary */

    delay += platform_get_audio_usecase_delay(out->usecase);

    return delay;

}



int64_t platform_capture_latency(struct stream_in *in)

{

    int64_t delay = 0LL;



    if (!in)

        return delay;



    delay = platform_get_audio_source_delay(in->source);



/* in->device could be used to add delay time if it's necessary */

    return delay;

}



int platform_set_snd_device_backend(snd_device_t device, const char *backend, const char * hw_interface)

hal/msm8960/platform.c

+96 −5
Original line number Diff line number Diff line
@@ -226,6 +226,24 @@ static const int acdb_device_table[SND_DEVICE_MAX] = { 
#define DEEP_BUFFER_PLATFORM_DELAY (29*1000LL)

#define LOW_LATENCY_PLATFORM_DELAY (13*1000LL)



static int audio_usecase_delay_ms[AUDIO_USECASE_MAX] = {0};



static int audio_source_delay_ms[AUDIO_SOURCE_CNT] = {0};



static struct name_to_index audio_source_index[AUDIO_SOURCE_CNT] = {

    {TO_NAME_INDEX(AUDIO_SOURCE_DEFAULT)},

    {TO_NAME_INDEX(AUDIO_SOURCE_MIC)},

    {TO_NAME_INDEX(AUDIO_SOURCE_VOICE_UPLINK)},

    {TO_NAME_INDEX(AUDIO_SOURCE_VOICE_DOWNLINK)},

    {TO_NAME_INDEX(AUDIO_SOURCE_VOICE_CALL)},

    {TO_NAME_INDEX(AUDIO_SOURCE_CAMCORDER)},

    {TO_NAME_INDEX(AUDIO_SOURCE_VOICE_RECOGNITION)},

    {TO_NAME_INDEX(AUDIO_SOURCE_VOICE_COMMUNICATION)},

    {TO_NAME_INDEX(AUDIO_SOURCE_REMOTE_SUBMIX)},

    {TO_NAME_INDEX(AUDIO_SOURCE_UNPROCESSED)},

    {TO_NAME_INDEX(AUDIO_SOURCE_VOICE_PERFORMANCE)},

};



static pthread_once_t check_op_once_ctl = PTHREAD_ONCE_INIT;

static bool is_tmus = false;
@@ -1026,17 +1044,85 @@ int platform_set_parameters(void *platform __unused, 
    return -ENOSYS;

}



void platform_set_audio_source_delay(audio_source_t audio_source, int delay_ms)

{

    if ((audio_source < AUDIO_SOURCE_DEFAULT) ||

           (audio_source > AUDIO_SOURCE_MAX)) {

        ALOGE("%s: Invalid audio_source = %d", __func__, audio_source);

        return;

    }



    audio_source_delay_ms[audio_source] = delay_ms;

}



/* Delay in Us */

int64_t platform_get_audio_source_delay(audio_source_t audio_source)

{

    if ((audio_source < AUDIO_SOURCE_DEFAULT) ||

            (audio_source > AUDIO_SOURCE_MAX)) {

        ALOGE("%s: Invalid audio_source = %d", __func__, audio_source);

        return 0;

    }



    return 1000LL * audio_source_delay_ms[audio_source];

}



void platform_set_audio_usecase_delay(audio_usecase_t usecase, int delay_ms)

{

    if ((usecase <= USECASE_INVALID) || (usecase >= AUDIO_USECASE_MAX)) {

        ALOGE("%s: invalid usecase case idx %d", __func__, usecase);

        return;

    }



    audio_usecase_delay_ms[usecase] = delay_ms;

}



/* Delay in Us */

int64_t platform_get_audio_usecase_delay(audio_usecase_t usecase)

{

    if ((usecase <= USECASE_INVALID) || (usecase >= AUDIO_USECASE_MAX)) {

        ALOGE("%s: invalid usecase case idx %d", __func__, usecase);

        return 0;

    }



    return 1000LL *  audio_usecase_delay_ms[usecase] ;

}



/* Delay in Us */

int64_t platform_render_latency(audio_usecase_t usecase)

int64_t platform_render_latency(struct stream_out *out)

{

    switch (usecase) {

    int64_t delay = 0LL;



    if (!out)

        return delay;



    switch (out->usecase) {

        case USECASE_AUDIO_PLAYBACK_DEEP_BUFFER:

            return DEEP_BUFFER_PLATFORM_DELAY;

            delay = DEEP_BUFFER_PLATFORM_DELAY;

            break;

        case USECASE_AUDIO_PLAYBACK_LOW_LATENCY:

            return LOW_LATENCY_PLATFORM_DELAY;

            delay = LOW_LATENCY_PLATFORM_DELAY;

            break;

        default:

            return 0;

            break;

    }



/* out->usecase could be used to add delay time if it's necessary */

    delay += platform_get_audio_usecase_delay(out->usecase);

    return delay;

}



int64_t platform_capture_latency(struct stream_in *in)

{

    int64_t delay = 0LL;



    if (!in)

        return delay;



    delay = platform_get_audio_source_delay(in->source);



/* in->device could be used to add delay time if it's necessary */

    return delay;

}



int platform_switch_voice_call_enable_device_config(void *platform __unused,
@@ -1063,6 +1149,11 @@ int platform_get_usecase_index(const char * usecase __unused) 
    return -ENOSYS;

}



int platform_get_audio_source_index(const char *audio_source_name)

{

    return find_index(audio_source_index, AUDIO_SOURCE_CNT, audio_source_name);

}



int platform_set_usecase_pcm_id(audio_usecase_t usecase __unused, int32_t type __unused,

                                int32_t pcm_id __unused)

{

hal/msm8974/platform.c

+100 −7
Original line number Diff line number Diff line
@@ -741,6 +741,24 @@ static struct listnode app_type_entry_list; 
#define ULL_PLATFORM_DELAY         (3*1000LL)

#define MMAP_PLATFORM_DELAY        (3*1000LL)



static int audio_usecase_delay_ms[AUDIO_USECASE_MAX] = {0};



static int audio_source_delay_ms[AUDIO_SOURCE_CNT] = {0};



static struct name_to_index audio_source_index[AUDIO_SOURCE_CNT] = {

    {TO_NAME_INDEX(AUDIO_SOURCE_DEFAULT)},

    {TO_NAME_INDEX(AUDIO_SOURCE_MIC)},

    {TO_NAME_INDEX(AUDIO_SOURCE_VOICE_UPLINK)},

    {TO_NAME_INDEX(AUDIO_SOURCE_VOICE_DOWNLINK)},

    {TO_NAME_INDEX(AUDIO_SOURCE_VOICE_CALL)},

    {TO_NAME_INDEX(AUDIO_SOURCE_CAMCORDER)},

    {TO_NAME_INDEX(AUDIO_SOURCE_VOICE_RECOGNITION)},

    {TO_NAME_INDEX(AUDIO_SOURCE_VOICE_COMMUNICATION)},

    {TO_NAME_INDEX(AUDIO_SOURCE_REMOTE_SUBMIX)},

    {TO_NAME_INDEX(AUDIO_SOURCE_UNPROCESSED)},

    {TO_NAME_INDEX(AUDIO_SOURCE_VOICE_PERFORMANCE)},

};



static pthread_once_t check_op_once_ctl = PTHREAD_ONCE_INIT;

static bool is_tmus = false;
@@ -2254,6 +2272,11 @@ done: 
    return ret;

}



int platform_get_audio_source_index(const char *audio_source_name)

{

    return find_index(audio_source_index, AUDIO_SOURCE_CNT, audio_source_name);

}



void platform_add_operator_specific_device(snd_device_t snd_device,

                                           const char *operator,

                                           const char *mixer_path,
@@ -3828,22 +3851,92 @@ done: 
    return ret;

}



void platform_set_audio_source_delay(audio_source_t audio_source, int delay_ms)

{

    if ((audio_source < AUDIO_SOURCE_DEFAULT) ||

           (audio_source > AUDIO_SOURCE_MAX)) {

        ALOGE("%s: Invalid audio_source = %d", __func__, audio_source);

        return;

    }



    audio_source_delay_ms[audio_source] = delay_ms;

}



/* Delay in Us */

int64_t platform_get_audio_source_delay(audio_source_t audio_source)

{

    if ((audio_source < AUDIO_SOURCE_DEFAULT) ||

            (audio_source > AUDIO_SOURCE_MAX)) {

        ALOGE("%s: Invalid audio_source = %d", __func__, audio_source);

        return 0;

    }



    return 1000LL * audio_source_delay_ms[audio_source];

}



void platform_set_audio_usecase_delay(audio_usecase_t usecase, int delay_ms)

{

    if ((usecase <= USECASE_INVALID) || (usecase >= AUDIO_USECASE_MAX)) {

        ALOGE("%s: invalid usecase case idx %d", __func__, usecase);

        return;

    }



    audio_usecase_delay_ms[usecase] = delay_ms;

}



/* Delay in Us */

int64_t platform_render_latency(audio_usecase_t usecase)

int64_t platform_get_audio_usecase_delay(audio_usecase_t usecase)

{

    switch (usecase) {

    if ((usecase <= USECASE_INVALID) || (usecase >= AUDIO_USECASE_MAX)) {

        ALOGE("%s: invalid usecase case idx %d", __func__, usecase);

        return 0;

    }



    return 1000LL *  audio_usecase_delay_ms[usecase] ;

}



/* Delay in Us */

int64_t platform_render_latency(struct stream_out *out)

{

    int64_t delay = 0LL;



    if (!out)

        return delay;



    switch (out->usecase) {

        case USECASE_AUDIO_PLAYBACK_DEEP_BUFFER:

            return DEEP_BUFFER_PLATFORM_DELAY;

            delay = DEEP_BUFFER_PLATFORM_DELAY;

            break;

        case USECASE_AUDIO_PLAYBACK_LOW_LATENCY:

        case USECASE_AUDIO_PLAYBACK_WITH_HAPTICS:

            return LOW_LATENCY_PLATFORM_DELAY;

            delay = LOW_LATENCY_PLATFORM_DELAY;

            break;

        case USECASE_AUDIO_PLAYBACK_ULL:

            return ULL_PLATFORM_DELAY;

            delay = ULL_PLATFORM_DELAY;

            break;

        case USECASE_AUDIO_PLAYBACK_MMAP:

            return MMAP_PLATFORM_DELAY;

            delay = MMAP_PLATFORM_DELAY;

            break;

        default:

            return 0;

            break;

    }



/* out->usecase could be used to add delay time if it's necessary */

    delay += platform_get_audio_usecase_delay(out->usecase);

    return delay;

}



int64_t platform_capture_latency(struct stream_in *in)

{

    int64_t delay = 0LL;



    if (!in)

        return delay;



    delay = platform_get_audio_source_delay(in->source);



/* in->device could be used to add delay time if it's necessary */

    return delay;

}



int platform_set_snd_device_backend(snd_device_t device, const char *backend_tag,

hal/platform_api.h

+8 −1
Original line number Diff line number Diff line
@@ -127,7 +127,8 @@ int platform_get_gain_level_mapping(struct amp_db_and_gain_table *mapping_tbl, 
                                    int table_size);



/* returns the latency for a usecase in Us */

int64_t platform_render_latency(audio_usecase_t usecase);

int64_t platform_render_latency(struct stream_out *out);

int64_t platform_capture_latency(struct stream_in *in);



int platform_set_incall_recording_session_id(void *platform,

                                             uint32_t session_id, int rec_mode);
@@ -209,6 +210,12 @@ int platform_get_usb_service_interval(void *platform, 
                                      unsigned long *service_interval);

int platform_get_haptics_pcm_device_id();



void platform_set_audio_source_delay(audio_source_t audio_source, int delay_ms);



int platform_get_audio_source_index(const char *audio_source_name);



void platform_set_audio_usecase_delay(audio_usecase_t usecase, int delay_ms);



/* callback functions from platform to common audio HAL */

struct stream_in *adev_get_active_input(const struct audio_device *adev);