android/hal-audio: Use hal-utils helpers for unaligned access

[android-x86/external-bluetooth-bluez.git] / android / hal-audio.c

diff --git a/android/hal-audio.c b/android/hal-audio.c
index a7cda8a..e70351e 100644 (file)
--- a/android/hal-audio.c
+++ b/android/hal-audio.c
@@ -35,8 +35,7 @@
 #include "hal-log.h"
 #include "hal-msg.h"
 #include "hal-audio.h"
-#include "src/shared/util.h"
-#include "src/shared/queue.h"
+#include "hal-utils.h"
 
 #define FIXED_A2DP_PLAYBACK_LATENCY_MS 25
 
@@ -97,16 +96,18 @@ extern int clock_nanosleep(clockid_t clock_id, int flags,
                                        struct timespec *remain);
 #endif
 
-static const audio_codec_get_t audio_codecs[] = {
-               codec_sbc,
+static struct {
+       const audio_codec_get_t get_codec;
+       bool loaded;
+} audio_codecs[] = {
+               { .get_codec = codec_aptx, .loaded = false },
+               { .get_codec = codec_sbc, .loaded = false },
 };
 
 #define NUM_CODECS (sizeof(audio_codecs) / sizeof(audio_codecs[0]))
 
 #define MAX_AUDIO_ENDPOINTS NUM_CODECS
 
-static struct queue *loaded_codecs;
-
 struct audio_endpoint {
        uint8_t id;
        const struct audio_codec *codec;
@@ -285,8 +286,7 @@ static int audio_ipc_cmd(uint8_t service_id, uint8_t opcode, uint16_t len,
                        goto failed;
        }
 
-       if (rsp_len)
-               *rsp_len = cmd.len;
+       *rsp_len = cmd.len;
 
        return AUDIO_STATUS_SUCCESS;
 
@@ -423,10 +423,9 @@ struct register_state {
        bool error;
 };
 
-static void register_endpoint(void *data, void *user_data)
+static void register_endpoint(const struct audio_codec *codec,
+                                               struct register_state *state)
 {
-       struct audio_codec *codec = data;
-       struct register_state *state = user_data;
        struct audio_endpoint *ep = state->ep;
 
        /* don't even try to register more endpoints if one failed */
@@ -451,11 +450,19 @@ static void register_endpoint(void *data, void *user_data)
 static int register_endpoints(void)
 {
        struct register_state state;
+       unsigned int i;
 
        state.ep = &audio_endpoints[0];
        state.error = false;
 
-       queue_foreach(loaded_codecs, register_endpoint, &state);
+       for (i = 0; i < NUM_CODECS; i++) {
+               const struct audio_codec *codec = audio_codecs[i].get_codec();
+
+               if (!audio_codecs[i].loaded)
+                       continue;
+
+               register_endpoint(codec, &state);
+       }
 
        return state.error ? AUDIO_STATUS_FAILED : AUDIO_STATUS_SUCCESS;
 }
@@ -503,7 +510,7 @@ static bool open_endpoint(struct audio_endpoint **epp,
 
        if (!ep) {
                error("Cound not find opened endpoint");
-               return false;
+               goto failed;
        }
 
        *epp = ep;
@@ -581,10 +588,10 @@ static void downmix_to_mono(struct a2dp_stream_out *out, const uint8_t *buffer,
        frames = bytes / (2 * sizeof(int16_t));
 
        for (i = 0; i < frames; i++) {
-               int16_t l = le16_to_cpu(get_unaligned(&input[i * 2]));
-               int16_t r = le16_to_cpu(get_unaligned(&input[i * 2 + 1]));
+               int16_t l = get_le16(&input[i * 2]);
+               int16_t r = get_le16(&input[i * 2 + 1]);
 
-               put_unaligned(cpu_to_le16((l + r) / 2), &output[i]);
+               put_le16((l + r) / 2, &output[i]);
        }
 }
 
@@ -1293,24 +1300,26 @@ static int audio_dump(const audio_hw_device_t *device, int fd)
        return -ENOSYS;
 }
 
-static void unload_codec(void *data)
-{
-       struct audio_codec *codec = data;
-
-       if (codec->unload)
-               codec->unload();
-}
-
 static int audio_close(hw_device_t *device)
 {
        struct a2dp_audio_dev *a2dp_dev = (struct a2dp_audio_dev *)device;
+       unsigned int i;
 
        DBG("");
 
        unregister_endpoints();
 
-       queue_destroy(loaded_codecs, unload_codec);
-       loaded_codecs = NULL;
+       for (i = 0; i < NUM_CODECS; i++) {
+               const struct audio_codec *codec = audio_codecs[i].get_codec();
+
+               if (!audio_codecs[i].loaded)
+                       continue;
+
+               if (codec->unload)
+                       codec->unload();
+
+               audio_codecs[i].loaded = false;
+       }
 
        shutdown(listen_sk, SHUT_RDWR);
        shutdown(audio_sk, SHUT_RDWR);
@@ -1376,14 +1385,12 @@ static void *ipc_handler(void *data)
                /* Check if socket is still alive. Empty while loop.*/
                while (poll(&pfd, 1, -1) < 0 && errno == EINTR);
 
-               if (pfd.revents & (POLLHUP | POLLERR | POLLNVAL)) {
-                       info("Audio HAL: Socket closed");
+               info("Audio HAL: Socket closed");
 
-                       pthread_mutex_lock(&sk_mutex);
-                       close(audio_sk);
-                       audio_sk = -1;
-                       pthread_mutex_unlock(&sk_mutex);
-               }
+               pthread_mutex_lock(&sk_mutex);
+               close(audio_sk);
+               audio_sk = -1;
+               pthread_mutex_unlock(&sk_mutex);
        }
 
        /* audio_sk is closed at this point, just cleanup endpoints states */
@@ -1490,16 +1497,13 @@ static int audio_open(const hw_module_t *module, const char *name,
        a2dp_dev->dev.close_input_stream = audio_close_input_stream;
        a2dp_dev->dev.dump = audio_dump;
 
-       loaded_codecs = queue_new();
-
        for (i = 0; i < NUM_CODECS; i++) {
-               audio_codec_get_t get_codec = audio_codecs[i];
-               const struct audio_codec *codec = get_codec();
+               const struct audio_codec *codec = audio_codecs[i].get_codec();
 
                if (codec->load && !codec->load())
                        continue;
 
-               queue_push_tail(loaded_codecs, (void *) codec);
+               audio_codecs[i].loaded = true;
        }
 
        /*