external: tinycompress: add support for compress plugins
Add plugin support to use vendor specific compress implementation
Bug: 166667071
Test: manual offload playback test
Test: cts AudioTrackOffloadTest
CRs-Fixed: 2563258
Change-Id: I71f588b9ed84b62d3b1b08dae7ce65f8fa649e6a
diff --git a/compress_plugin.c b/compress_plugin.c
new file mode 100644
index 0000000..d445ae9
--- /dev/null
+++ b/compress_plugin.c
@@ -0,0 +1,423 @@
+/* compress_plugin.c
+**
+** Copyright (c) 2019, The Linux Foundation. All rights reserved.
+**
+** Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+** * Redistributions of source code must retain the above copyright
+** notice, this list of conditions and the following disclaimer.
+** * Redistributions in binary form must reproduce the above
+** copyright notice, this list of conditions and the following
+** disclaimer in the documentation and/or other materials provided
+** with the distribution.
+** * Neither the name of The Linux Foundation nor the names of its
+** contributors may be used to endorse or promote products derived
+** from this software without specific prior written permission.
+**
+** THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+** WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+** ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+** BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+** CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+** SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+** BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+** WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+** OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+** IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+**/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <fcntl.h>
+#include <stdarg.h>
+#include <string.h>
+#include <errno.h>
+#include <unistd.h>
+#include <poll.h>
+#include <dlfcn.h>
+
+#include <sys/ioctl.h>
+#include <linux/ioctl.h>
+#include <sound/asound.h>
+#include "tinycompress/compress_plugin.h"
+#include "sound/compress_offload.h"
+#include "compress_ops.h"
+#include "snd_utils.h"
+
+#define U32_MAX ((uint32_t)~0U)
+
+enum {
+ COMPRESS_PLUG_STATE_OPEN,
+ COMPRESS_PLUG_STATE_SETUP,
+ COMPRESS_PLUG_STATE_PREPARED,
+ COMPRESS_PLUG_STATE_PAUSE,
+ COMPRESS_PLUG_STATE_RUNNING,
+};
+
+struct compress_plug_data {
+ unsigned int card;
+ unsigned int device;
+ unsigned int fd;
+ unsigned int flags;
+
+ void *dl_hdl;
+ COMPRESS_PLUGIN_OPEN_FN_PTR();
+
+ struct compress_plugin *plugin;
+ void *dev_node;
+};
+
+static int compress_plug_get_caps(struct compress_plug_data *plug_data,
+ struct snd_compr_caps *caps)
+{
+ struct compress_plugin *plugin = plug_data->plugin;
+
+ return plugin->ops->get_caps(plugin, caps);
+}
+
+static int compress_plug_set_params(struct compress_plug_data *plug_data,
+ struct snd_compr_params *params)
+{
+ struct compress_plugin *plugin = plug_data->plugin;
+ int rc;
+
+ if (plugin->state != COMPRESS_PLUG_STATE_OPEN)
+ return -EBADFD;
+
+ if (params->buffer.fragment_size == 0 ||
+ params->buffer.fragments > U32_MAX / params->buffer.fragment_size ||
+ params->buffer.fragments == 0)
+ return -EINVAL;
+
+ rc = plugin->ops->set_params(plugin, params);
+ if (!rc)
+ plugin->state = COMPRESS_PLUG_STATE_SETUP;
+
+ return rc;
+}
+
+static int compress_plug_avail(struct compress_plug_data *plug_data,
+ struct snd_compr_avail *avail)
+{
+ struct compress_plugin *plugin = plug_data->plugin;
+
+ return plugin->ops->avail(plugin, avail);
+}
+
+static int compress_plug_tstamp(struct compress_plug_data *plug_data,
+ struct snd_compr_tstamp *tstamp)
+{
+ struct compress_plugin *plugin = plug_data->plugin;
+
+ if (plugin->state != COMPRESS_PLUG_STATE_SETUP)
+ return -EBADFD;
+
+ return plugin->ops->tstamp(plugin, tstamp);
+}
+
+static int compress_plug_start(struct compress_plug_data *plug_data)
+{
+ struct compress_plugin *plugin = plug_data->plugin;
+ int rc;
+
+ /* for playback moved to prepare in first write */
+ /* for capture: move to prepare state set params */
+ /* TODO: add direction in set params */
+ if (plugin->state != COMPRESS_PLUG_STATE_PREPARED)
+ return -EBADFD;
+
+ rc = plugin->ops->start(plugin);
+ if (!rc)
+ plugin->state = COMPRESS_PLUG_STATE_RUNNING;
+
+ return rc;
+}
+
+static int compress_plug_stop(struct compress_plug_data *plug_data)
+{
+ struct compress_plugin *plugin = plug_data->plugin;
+ int rc;
+
+ if (plugin->state == COMPRESS_PLUG_STATE_PREPARED ||
+ plugin->state == COMPRESS_PLUG_STATE_SETUP)
+ return -EBADFD;
+
+ rc = plugin->ops->stop(plugin);
+ if (!rc)
+ plugin->state = COMPRESS_PLUG_STATE_SETUP;
+
+ return rc;
+}
+
+static int compress_plug_pause(struct compress_plug_data *plug_data)
+{
+ struct compress_plugin *plugin = plug_data->plugin;
+ int rc;
+
+ if (plugin->state != COMPRESS_PLUG_STATE_RUNNING)
+ return -EBADFD;
+
+ rc = plugin->ops->pause(plugin);
+ if (!rc)
+ plugin->state = COMPRESS_PLUG_STATE_PAUSE;
+
+ return rc;
+}
+
+static int compress_plug_resume(struct compress_plug_data *plug_data)
+{
+ struct compress_plugin *plugin = plug_data->plugin;
+ int rc;
+
+ if (plugin->state != COMPRESS_PLUG_STATE_PAUSE)
+ return -EBADFD;
+
+ rc = plugin->ops->resume(plugin);
+ if (!rc)
+ plugin->state = COMPRESS_PLUG_STATE_RUNNING;
+
+ return rc;
+}
+
+static int compress_plug_drain(struct compress_plug_data *plug_data)
+{
+ struct compress_plugin *plugin = plug_data->plugin;
+
+ /* check if we will allow in pause */
+ if (plugin->state != COMPRESS_PLUG_STATE_RUNNING)
+ return -EBADFD;
+
+ return plugin->ops->drain(plugin);
+}
+
+static int compress_plug_partial_drain(struct compress_plug_data *plug_data)
+{
+ struct compress_plugin *plugin = plug_data->plugin;
+
+ /* check if we will allow in pause */
+ if (plugin->state != COMPRESS_PLUG_STATE_RUNNING)
+ return -EBADFD;
+
+ return plugin->ops->partial_drain(plugin);
+}
+
+static int compress_plug_next_track(struct compress_plug_data *plug_data)
+{
+ struct compress_plugin *plugin = plug_data->plugin;
+
+ /* transion to next track applied to running stream only */
+ if (plugin->state != COMPRESS_PLUG_STATE_RUNNING)
+ return -EBADFD;
+
+ return plugin->ops->next_track(plugin);
+}
+
+static int compress_plug_ioctl(void *data, unsigned int cmd, ...)
+{
+ struct compress_plug_data *plug_data = data;
+ struct compress_plugin *plugin = plug_data->plugin;
+ int ret = 0;
+ va_list ap;
+ void *arg;
+
+ va_start(ap, cmd);
+ arg = va_arg(ap, void *);
+ va_end(ap);
+
+ switch (cmd) {
+ case SNDRV_COMPRESS_IOCTL_VERSION:
+ *((int*)arg) = SNDRV_COMPRESS_VERSION;
+ break;
+ case SNDRV_COMPRESS_GET_CAPS:
+ ret = compress_plug_get_caps(plug_data, arg);
+ break;
+ case SNDRV_COMPRESS_SET_PARAMS:
+ ret = compress_plug_set_params(plug_data, arg);
+ break;
+ case SNDRV_COMPRESS_AVAIL:
+ ret = compress_plug_avail(plug_data, arg);
+ break;
+ case SNDRV_COMPRESS_TSTAMP:
+ ret = compress_plug_tstamp(plug_data, arg);
+ break;
+ case SNDRV_COMPRESS_START:
+ ret = compress_plug_start(plug_data);
+ break;
+ case SNDRV_COMPRESS_STOP:
+ ret = compress_plug_stop(plug_data);
+ break;
+ case SNDRV_COMPRESS_PAUSE:
+ ret = compress_plug_pause(plug_data);
+ break;
+ case SNDRV_COMPRESS_RESUME:
+ ret = compress_plug_resume(plug_data);
+ break;
+ case SNDRV_COMPRESS_DRAIN:
+ ret = compress_plug_drain(plug_data);
+ break;
+ case SNDRV_COMPRESS_PARTIAL_DRAIN:
+ ret = compress_plug_partial_drain(plug_data);
+ break;
+ case SNDRV_COMPRESS_NEXT_TRACK:
+ ret = compress_plug_next_track(plug_data);
+ break;
+ default:
+ if (plugin->ops->ioctl)
+ ret = plugin->ops->ioctl(plugin, cmd, arg);
+ else
+ ret = -EINVAL;
+ break;
+ }
+
+ return ret;
+}
+
+static int compress_plug_poll(void *data, struct pollfd *fds,
+ nfds_t nfds, int timeout)
+{
+ struct compress_plug_data *plug_data = data;
+ struct compress_plugin *plugin = plug_data->plugin;
+
+ if (plugin->state != COMPRESS_PLUG_STATE_RUNNING)
+ return -EBADFD;
+
+ return plugin->ops->poll(plugin, fds, nfds, timeout);
+}
+
+
+static int compress_plug_read(void *data, void *buf, size_t size)
+{
+ struct compress_plug_data *plug_data = data;
+ struct compress_plugin *plugin = plug_data->plugin;
+
+ if (plugin->state != COMPRESS_PLUG_STATE_RUNNING &&
+ plugin->state != COMPRESS_PLUG_STATE_SETUP)
+ return -EBADFD;
+
+ return plugin->ops->read(plugin, buf, size);
+}
+
+static int compress_plug_write(void *data, const void *buf, size_t size)
+{
+ struct compress_plug_data *plug_data = data;
+ struct compress_plugin *plugin = plug_data->plugin;
+ int rc;
+
+ if (plugin->state != COMPRESS_PLUG_STATE_SETUP &&
+ plugin->state != COMPRESS_PLUG_STATE_PREPARED &&
+ plugin->state != COMPRESS_PLUG_STATE_RUNNING)
+ return -EBADFD;
+
+ rc = plugin->ops->write(plugin, buf, size);
+ if ((rc > 0) && (plugin->state == COMPRESS_PLUG_STATE_SETUP))
+ plugin->state = COMPRESS_PLUG_STATE_PREPARED;
+
+ return rc;
+}
+
+static void compress_plug_close(void *data)
+{
+ struct compress_plug_data *plug_data = data;
+ struct compress_plugin *plugin = plug_data->plugin;
+
+ plugin->ops->close(plugin);
+ dlclose(plug_data->dl_hdl);
+
+ free(plug_data);
+}
+
+static int compress_plug_open(unsigned int card, unsigned int device,
+ unsigned int flags, void **data, void *node)
+{
+ struct compress_plug_data *plug_data;
+ const char *err = NULL;
+ void *dl_hdl;
+ int rc = 0;
+ char *so_name, *open_fn, token[80], *name;
+
+ plug_data = calloc(1, sizeof(*plug_data));
+ if (!plug_data) {
+ return -ENOMEM;
+ }
+
+ rc = snd_utils_get_str(node, "so-name", &so_name);
+ if (rc) {
+ fprintf(stderr, "%s: failed to get plugin lib name\n",
+ __func__);
+ goto err_get_lib;
+ }
+
+ dl_hdl = dlopen(so_name, RTLD_NOW);
+ if (!dl_hdl) {
+ fprintf(stderr, "%s: unable to open %s, error: %s\n",
+ __func__, so_name, dlerror());
+ goto err_dl_open;
+ } else {
+ fprintf(stderr, "%s: dlopen successful for %s\n",
+ __func__, so_name);
+ }
+
+ sscanf(so_name, "lib%s", token);
+ name = strtok(token, ".");
+ open_fn = calloc(1, strlen(name) + strlen("_open") + 1);
+ if (!open_fn) {
+ rc = -ENOMEM;
+ goto err_open_fn;
+ }
+
+ strncpy(open_fn, name, strlen(name) + 1);
+ strcat(open_fn, "_open");
+
+ plug_data->plugin_open_fn = dlsym(dl_hdl, open_fn);
+ err = dlerror();
+
+ if (err) {
+ fprintf(stderr, "%s: dlsym to open fn failed, err = '%s'\n",
+ __func__, err);
+ goto err_dlsym;
+ }
+
+ rc = plug_data->plugin_open_fn(&plug_data->plugin,
+ card, device, flags);
+ if (rc) {
+ fprintf(stderr, "%s: failed to open plugin\n", __func__);
+ goto err_dlsym;
+ }
+
+ /* Call snd-card-def to get card and compress nodes */
+ /* Check how to manage fd for plugin */
+
+ plug_data->dl_hdl = dl_hdl;
+ plug_data->card = card;
+ plug_data->device = device;
+ plug_data->dev_node = node;
+ plug_data->flags = flags;
+
+ *data = plug_data;
+
+ plug_data->plugin->state = COMPRESS_PLUG_STATE_OPEN;
+
+ return 0;
+
+err_dlsym:
+ free(open_fn);
+err_open_fn:
+ dlclose(dl_hdl);
+err_get_lib:
+err_dl_open:
+ free(plug_data);
+
+ return rc;
+}
+
+struct compress_ops compr_plug_ops = {
+ .open = compress_plug_open,
+ .close = compress_plug_close,
+ .ioctl = compress_plug_ioctl,
+ .read = compress_plug_read,
+ .write = compress_plug_write,
+ .poll = compress_plug_poll,
+};