j721e: audio: Implement the changes required for CDD compliance using 16 bit audio format.d-pie-core-release

As per Android's CDD doc (https://source.android.com/compatibility/9/android-9-cdd), the
audio HAL must support audio resampling between 8000, 11025, 16000, 44100 Hz using
Linear PCM, 16-bit format.But the Android's speex library cannot handle resampling of
24 bit audio format hence fall back to 16 bit audio format for both playback and
recording.

2 files changed, 376 insertions, 11 deletions

diff --git a/audio/primary/audio_hw.c b/audio/primary/audio_hw.c
index 7787ad9..6c9b3cc 100644
--- a/audio/primary/audio_hw.c
+++ b/audio/primary/audio_hw.c
@@ -42,7 +42,18 @@
 /* yet another definition of ARRAY_SIZE macro) */
 #define ARRAY_SIZE(x)           (sizeof(x)/sizeof(x[0]))
 
-#define DEFAULT_AUDIO_FORMAT  AUDIO_FORMAT_PCM_24_BIT_PACKED
+#define DEFAULT_AUDIO_FORMAT  AUDIO_FORMAT_PCM_16_BIT
+/* buffer_remix: functor for doing in-place buffer manipulations.
+ *
+ * NB. When remix_func is called, the memory at `buf` must be at least
+ * as large as frames * sample_size * MAX(in_chans, out_chans).
+ */
+struct buffer_remix {
+    void (*remix_func)(struct buffer_remix *data, void *buf, size_t frames);
+    size_t sample_size; /* size of one audio sample, in bytes */
+    size_t in_chans;    /* number of input channels */
+    size_t out_chans;   /* number of output channels */
+};
 
 struct j7_audio_device {
     struct audio_hw_device device;
@@ -60,7 +71,10 @@ struct j7_stream_in {
     struct j7_audio_device *dev;
     struct pcm_config config;
     struct pcm *pcm;
+    struct buffer_remix *remix; /* adapt hw chan count to client */
+    struct resampler_itfe *resampler;
     struct resampler_buffer_provider buf_provider;
+    int16_t *buffer;
     size_t frames_in;
     size_t hw_frame_size;
     unsigned int requested_rate;
@@ -78,14 +92,17 @@ struct j7_stream_out {
     struct j7_audio_device *dev;
     struct pcm_config config;
     struct pcm *pcm;
+    struct resampler_itfe *resampler;
     struct timespec last;
     pthread_mutex_t lock;
+    int16_t *buffer;
     size_t hw_frame_size;
     unsigned int requested_rate;
     unsigned int requested_channels;
     unsigned int card;
     unsigned int port;
     audio_devices_t device;
+    bool needs_remix;
     bool standby;
     int64_t written; /* total frames written, not cleared when entering standby */
 };
@@ -95,7 +112,7 @@ static const char *supported_media_cards[] = {
 };
 
 #define MAX_CARD_COUNT                  1
-#define BYTES_PER_SAMPLE (3) //for 24 bit 3 bytes are required
+#define BYTES_PER_SAMPLE (2) //for 16 bit 2 bytes are required
 
 #define SUPPORTED_IN_DEVICES           (AUDIO_DEVICE_IN_WIRED_HEADSET | \
                                         AUDIO_DEVICE_IN_DEFAULT)
@@ -118,7 +135,7 @@ static const char *supported_media_cards[] = {
 struct pcm_config pcm_config_capture = {
     .channels        = 2,/* Stereo mode */
     .rate            = CAPTURE_SAMPLE_RATE,/* 48K Hz*/
-    .format          = PCM_FORMAT_S24_3LE,
+    .format          = PCM_FORMAT_S16_LE,
     .period_size     = CAPTURE_PERIOD_SIZE,
     .period_count    = CAPTURE_PERIOD_COUNT,
     .start_threshold = 1,
@@ -128,7 +145,7 @@ struct pcm_config pcm_config_capture = {
 struct pcm_config pcm_config_playback = {
     .channels        = 2,/* Stereo mode */
     .rate            = PLAYBACK_SAMPLE_RATE,/* 48K Hz*/
-    .format          = PCM_FORMAT_S24_3LE,
+    .format          = PCM_FORMAT_S16_LE,
     .period_size     = PLAYBACK_PERIOD_SIZE,
     .period_count    = PLAYBACK_PERIOD_COUNT,
     .start_threshold = PLAYBACK_BUFFER_SIZE / 2,
@@ -179,6 +196,91 @@ static size_t get_input_buffer_size(uint32_t sample_rate, int format, int channe
 
     return size * channel_count * audio_bytes_per_sample(format);
 }
+
+/*
+ * Implementation of buffer_remix::remix_func that removes
+ * channels in place without doing any other processing.  The
+ * extra channels are truncated.
+ */
+static void remove_channels_from_buf(struct buffer_remix *data, void *buf, size_t frames)
+{
+    size_t samp_size, in_frame, out_frame;
+    size_t N, c;
+    char *s, *d;
+
+    ALOGV("remove_channels_from_buf() remix=%p buf=%p frames=%zu",
+           data, buf, frames);
+
+    if (frames == 0)
+        return;
+
+    samp_size = data->sample_size;
+    in_frame = data->in_chans * samp_size;
+    out_frame = data->out_chans * samp_size;
+
+    if (out_frame >= in_frame) {
+        ALOGE("BUG: remove_channels_from_buf() can not add channels to a buffer.\n");
+        return;
+    }
+
+    N = frames - 1;
+    d = (char*)buf + out_frame;
+    s = (char*)buf + in_frame;
+
+    /* take the first several channels and truncate the rest */
+    while (N--) {
+        for (c = 0; c < out_frame; ++c)
+            d[c] = s[c];
+        d += out_frame;
+        s += in_frame;
+    }
+}
+
+static int setup_stereo_to_mono_input_remix(struct j7_stream_in *in)
+{
+    ALOGV("setup_stereo_to_mono_input_remix() stream=%p", in);
+
+    struct buffer_remix *br = (struct buffer_remix *)calloc(1, sizeof(struct buffer_remix));
+    if (!br)
+        return -ENOMEM;
+
+    br->remix_func = remove_channels_from_buf;
+    br->sample_size = BYTES_PER_SAMPLE;
+    br->in_chans = 2;
+    br->out_chans = 1;
+    in->remix = br;
+
+    return 0;
+}
+
+
+static void mono_to_stereo(void *dst, const void *src, size_t frames, int sample_size)
+{
+    int in_frame, out_frame;
+    int N, c;
+    char *s, *d;
+
+    ALOGV("mono_to_stereo() src=%p dst=%p frames=%zu", src, dst, frames);
+
+    if (frames == 0)
+        return;
+
+    in_frame = sample_size;
+    out_frame = 2 * sample_size;
+
+    N = frames - 1;
+    d = (char *)dst + N * out_frame;
+    s = (char *)src + N * in_frame;
+
+    /* duplicate first channel into the rest of channels in the frame */
+    while (N-- >= 0) {
+        for (c = 0; c < out_frame; ++c)
+            d[c] = s[c % in_frame];
+        d -= out_frame;
+        s -= in_frame;
+    }
+}
+
 /* audio HAL functions */
 
 static uint32_t out_get_sample_rate(const struct audio_stream *stream)
@@ -388,9 +490,23 @@ static ssize_t out_write(struct audio_stream_out *stream, const void* buffer,
 
     pthread_mutex_unlock(&adev->lock);
 
-    hw_frames = frames;
-    hw_buf = buffer;
+        if (out->resampler) {
+            in_buf = (void *)buffer;
+            hw_frames = out->config.period_size;
+
+            out->resampler->resample_from_input(out->resampler,
+                                                in_buf, &frames,
+                                                out->buffer, &hw_frames);
+            hw_buf = out->buffer;
+        } else {
+            hw_frames = frames;
+            hw_buf = buffer;
+        }
 
+        if (out->needs_remix) {
+            mono_to_stereo(out->buffer, hw_buf, hw_frames, BYTES_PER_SAMPLE);
+            hw_buf = out->buffer;
+        }
     ret = pcm_write(out->pcm, hw_buf, hw_frames * out->hw_frame_size);
     if (ret) {
         ALOGE("out_write() failed to write audio data %d", ret);
@@ -617,6 +733,115 @@ static int in_set_gain(struct audio_stream_in *stream, float gain)
     return 0;
 }
 
+static int get_next_buffer(struct resampler_buffer_provider *buffer_provider,
+                           struct resampler_buffer* buffer)
+{
+    struct j7_stream_in *in;
+    struct buffer_remix *remix;
+
+    if (buffer_provider == NULL || buffer == NULL)
+        return -EINVAL;
+
+    in = (struct j7_stream_in *)((char *)buffer_provider -
+                                 offsetof(struct j7_stream_in, buf_provider));
+
+    if (in->pcm == NULL) {
+        buffer->raw = NULL;
+        buffer->frame_count = 0;
+        in->read_status = -ENODEV;
+        return -ENODEV;
+    }
+
+    if (in->frames_in == 0) {
+        in->read_status = pcm_read(in->pcm,
+                                   (void*)in->buffer,
+                                   buffer->frame_count * in->hw_frame_size);
+        if (in->read_status != 0) {
+            ALOGE("get_next_buffer() pcm_read error %d", in->read_status);
+            buffer->raw = NULL;
+            buffer->frame_count = 0;
+            return in->read_status;
+        }
+        in->frames_in = buffer->frame_count;
+
+        remix = in->remix;
+        if (remix)
+            remix->remix_func(remix, in->buffer, in->frames_in);
+    }
+
+    buffer->frame_count = (buffer->frame_count > in->frames_in) ?
+                                in->frames_in : buffer->frame_count;
+    buffer->i16 = in->buffer;
+
+    return in->read_status;
+}
+
+static void release_buffer(struct resampler_buffer_provider *buffer_provider,
+                                  struct resampler_buffer* buffer)
+{
+    struct j7_stream_in *in;
+
+    if (buffer_provider == NULL || buffer == NULL)
+        return;
+
+    in = (struct j7_stream_in *)((char *)buffer_provider -
+                                 offsetof(struct j7_stream_in, buf_provider));
+
+    in->frames_in -= buffer->frame_count;
+}
+
+/*
+ * read_frames() reads frames from kernel driver, down samples to capture rate
+ * if necessary and output the number of frames requested to the buffer specified
+ */
+static ssize_t read_frames(struct j7_stream_in *in, void *buffer, ssize_t frames)
+{
+    const struct audio_stream_in *s = (const struct audio_stream_in *)in;
+    ssize_t frames_wr = 0;
+    size_t frame_size;
+
+    ALOGV("read_frames() stream=%p frames=%zu", in, frames);
+
+    if (in->remix)
+        frame_size = audio_stream_in_frame_size(s);
+    else
+        frame_size = in->hw_frame_size;
+
+    while (frames_wr < frames) {
+        size_t frames_rd = frames - frames_wr;
+
+        if  (in->resampler) {
+            in->resampler->resample_from_provider(in->resampler,
+                    (int16_t *)((char *)buffer + frames_wr * frame_size),
+                    &frames_rd);
+        } else {
+            struct resampler_buffer buf = {
+                    { .raw = NULL, },
+                    .frame_count = frames_rd,
+            };
+
+            get_next_buffer(&in->buf_provider, &buf);
+            if (buf.raw) {
+                memcpy((char *)buffer + frames_wr * frame_size,
+                       buf.raw,
+                       buf.frame_count * frame_size);
+                frames_rd = buf.frame_count;
+            }
+            release_buffer(&in->buf_provider, &buf);
+        }
+
+        /* in->read_status is updated by getNextBuffer() also called by
+         * in->resampler->resample_from_provider() */
+        if (in->read_status != 0)
+            return in->read_status;
+
+        frames_wr += frames_rd;
+
+    }
+
+    return frames_wr;
+}
+
 static ssize_t in_read(struct audio_stream_in *stream, void* buffer,
                        size_t bytes)
 {
@@ -649,11 +874,22 @@ static ssize_t in_read(struct audio_stream_in *stream, void* buffer,
             pthread_mutex_unlock(&adev->lock);
             return -ENODEV;
         }
+
+        /* if no supported sample rate is available, use the resampler */
+        if (in->resampler) {
+            in->resampler->reset(in->resampler);
+            in->frames_in = 0;
+        }
+
         in->standby = false;
     }
 
     pthread_mutex_unlock(&adev->lock);
-    ret = pcm_read(in->pcm, buffer, bytes);
+
+    if (in->resampler || in->remix)
+        ret = read_frames(in, buffer, frames);
+    else
+        ret = pcm_read(in->pcm, buffer, bytes);
 
     if (ret < 0) {
         ALOGE("in_read() failed to read audio data %d", ret);
@@ -745,14 +981,70 @@ static int adev_open_output_stream(struct audio_hw_device *dev,
     out->requested_rate = config->sample_rate;
     out->requested_channels = popcount(config->channel_mask);
     out->hw_frame_size = out->config.channels * BYTES_PER_SAMPLE;
+    out->resampler = NULL;
+    out->buffer = NULL;
     out->written = 0;
     out->card = adev->card;
     out->port = 0;
     out->device = devices;
     adev->out = out;
+
+    /* mono-to-stereo remix since playback stream is stereo */
+    if (out->requested_channels == 1) {
+        ALOGV("adev_open_output_stream() mono-to-stereo remix needed");
+        out->needs_remix = true;
+    } else if (out->requested_channels == 2) {
+        out->needs_remix = false;
+    } else {
+        ALOGE("adev_open_output_stream() %d channels is not supported",
+              out->requested_channels);
+        ret = -ENOTSUP;
+        goto err1;
+    }
+
+    if (out->requested_rate != out->config.rate) {
+        ALOGV("adev_output_output_stream() resample needed, req=%uHz got=%uHz",
+              out->requested_rate, out->config.rate);
+
+        ret = create_resampler(out->requested_rate,
+                               out->config.rate,
+                               out->requested_channels,
+                               RESAMPLER_QUALITY_DEFAULT,
+                               NULL,
+                               &out->resampler);
+        if (ret) {
+            ALOGE("adev_open_output_stream() failed to create resampler %d", ret);
+            goto err1;
+        }
+    }
+
+    if (out->resampler || out->needs_remix) {
+        /*
+         * Supported sampling rates that require resampling are lower than the
+         * HAL's default sampling rate (44.1kHz) so a buffer as large as the HAL's
+         * will suffice
+         */
+        buffer_size = out->config.period_size * out->hw_frame_size;
+
+        if (out->needs_remix)
+            buffer_size *= 2;
+
+        out->buffer = malloc(buffer_size);
+        if (!out->buffer) {
+            ret = -ENOMEM;
+            goto err2;
+        }
+    }
+
     *stream_out = &out->stream;
 
     return 0;
+
+ err2:
+    release_resampler(out->resampler);
+ err1:
+    free(out);
+    return ret;
 }
 
 static void adev_close_output_stream(struct audio_hw_device *dev,
@@ -765,6 +1057,12 @@ static void adev_close_output_stream(struct audio_hw_device *dev,
 
     out_standby(&stream->common);
 
+    if (out->resampler)
+        release_resampler(out->resampler);
+
+    if (out->buffer)
+        free(out->buffer);
+
     free(out);
     adev->out = NULL;
 }
@@ -941,13 +1239,71 @@ static int adev_open_input_stream(struct audio_hw_device *dev,
     in->requested_rate = config->sample_rate;
     in->requested_channels = popcount(config->channel_mask);
     in->hw_frame_size = in->config.channels * BYTES_PER_SAMPLE;
+    in->remix = NULL;
+    in->resampler = NULL;
+    in->buffer = NULL;
     in->card = adev->card;
     in->port = 1;
     in->device = devices;
     adev->in = in;
+
+    /* in-place stereo-to-mono remix since capture stream is stereo */
+    if (in->requested_channels == 1) {
+        ALOGD("adev_open_input_stream() stereo-to-mono remix needed");
+        ret = setup_stereo_to_mono_input_remix(in);
+        if (ret) {
+            ALOGE("adev_open_input_stream() failed to setup remix %d", ret);
+            goto err1;
+        }
+    }
+
+    if (in->requested_rate != in->config.rate) {
+        ALOGD("adev_open_input_stream() resample needed, req=%uHz got=%uHz",
+              in->requested_rate, in->config.rate);
+
+        in->buf_provider.get_next_buffer = get_next_buffer;
+        in->buf_provider.release_buffer = release_buffer;
+        ret = create_resampler(in->config.rate,
+                               in->requested_rate,
+                               in->requested_channels,
+                               RESAMPLER_QUALITY_DEFAULT,
+                               &in->buf_provider,
+                               &in->resampler);
+        if (ret) {
+            ALOGE("adev_open_input_stream() failed to create resampler %d", ret);
+            goto err2;
+        }
+    }
+
+    /*
+     * buffer size needs to be enough to allow stereo-to-mono remix
+     * and resample if needed
+     */
+    if (in->resampler || in->remix) {
+        buffer_size = in->config.period_size * in->hw_frame_size;
+
+        if (in->resampler)
+            buffer_size *= 2;
+        if (in->remix)
+            buffer_size *= 2;
+
+        in->buffer = malloc(buffer_size);
+        if (!in->buffer) {
+            ret = -ENOMEM;
+            goto err3;
+        }
+    }
     *stream_in = &in->stream;
 
     return 0;
+
+ err3:
+    release_resampler(in->resampler);
+ err2:
+    free(in->remix);
+ err1:
+    free(in);
+    return ret;
 }
 
 static void adev_close_input_stream(struct audio_hw_device *dev,
@@ -960,6 +1316,15 @@ static void adev_close_input_stream(struct audio_hw_device *dev,
 
     in_standby(&stream->common);
 
+    if (in->resampler)
+        release_resampler(in->resampler);
+
+    if (in->remix)
+        free(in->remix);
+
+    if (in->buffer)
+        free(in->buffer);
+
     free(in);
     adev->in = NULL;
 }
diff --git a/audio/primary/audio_policy_configuration.xml b/audio/primary/audio_policy_configuration.xml
index a4fc066..3cd301e 100644
--- a/audio/primary/audio_policy_configuration.xml
+++ b/audio/primary/audio_policy_configuration.xml
@@ -10,13 +10,13 @@
 
     <mixPorts>
         <mixPort name="primary output" role="source" flags="AUDIO_OUTPUT_FLAG_PRIMARY">
-            <profile name="" format="AUDIO_FORMAT_PCM_24_BIT_PACKED"
+            <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
                      samplingRates="48000" channelMasks="AUDIO_CHANNEL_OUT_STEREO"/>
         </mixPort>
         <mixPort name="primary input" role="sink">
-            <profile name="" format="AUDIO_FORMAT_PCM_24_BIT_PACKED"
-                    samplingRates="48000"
-                    channelMasks="AUDIO_CHANNEL_IN_STEREO"/>
+            <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
+                    samplingRates="8000,11025,12000,16000,22050,24000,32000,44100,48000"
+                    channelMasks="AUDIO_CHANNEL_IN_MONO,AUDIO_CHANNEL_IN_STEREO"/>
         </mixPort>
     </mixPorts>