/* * BSD LICENSE * * tinycompress library for compress audio offload in alsa * Copyright (c) 2011-2012, Intel Corporation * All rights reserved. * * Author: Vinod Koul <vinod.koul@linux.intel.com> * * 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 Intel Corporation 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 BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * 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. * * LGPL LICENSE * * tinycompress library for compress audio offload in alsa * Copyright (c) 2011-2012, Intel Corporation. * * * This program is free software; you can redistribute it and/or modify it * under the terms and conditions of the GNU Lesser General Public License, * version 2.1, as published by the Free Software Foundation. * * This program is distributed in the hope it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public * License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to * the Free Software Foundation, Inc., * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA. */ #include <stdio.h> #include <stdlib.h> #include <fcntl.h> #include <stdarg.h> #include <string.h> #include <errno.h> #include <unistd.h> #include <poll.h> #include <stdbool.h> #include <sys/ioctl.h> #include <sys/mman.h> #include <sys/time.h> #include <limits.h> #include <linux/types.h> #include <linux/ioctl.h> #define __force #define __bitwise #define __user #include <sound/asound.h> #include "sound/compress_params.h" #include "sound/compress_offload.h" #include "tinycompress/tinycompress.h" #define COMPR_ERR_MAX 128 /* Default maximum time we will wait in a poll() - 20 seconds */ #define DEFAULT_MAX_POLL_WAIT_MS 20000 struct compress { int fd; unsigned int flags; char error[COMPR_ERR_MAX]; struct compr_config *config; int running; int max_poll_wait_ms; int nonblocking; unsigned int gapless_metadata; unsigned int next_track; }; static int oops(struct compress *compress, int e, const char *fmt, ...) { va_list ap; int sz; va_start(ap, fmt); vsnprintf(compress->error, COMPR_ERR_MAX, fmt, ap); va_end(ap); sz = strlen(compress->error); snprintf(compress->error + sz, COMPR_ERR_MAX - sz, ": %s", strerror(e)); errno = e; return -1; } const char *compress_get_error(struct compress *compress) { return compress->error; } static struct compress bad_compress = { .fd = -1, }; int is_compress_running(struct compress *compress) { return ((compress->fd > 0) && compress->running) ? 1 : 0; } int is_compress_ready(struct compress *compress) { return (compress->fd > 0) ? 1 : 0; } static int get_compress_version(struct compress *compress) { int version = 0; if (ioctl(compress->fd, SNDRV_COMPRESS_IOCTL_VERSION, &version)) { oops(compress, errno, "cant read version"); return -1; } return version; } static bool _is_codec_supported(struct compress *compress, struct compr_config *config, const struct snd_compr_caps *caps) { bool codec = false; unsigned int i; for (i = 0; i < caps->num_codecs; i++) { if (caps->codecs[i] == config->codec->id) { /* found the codec */ codec = true; break; } } if (codec == false) { oops(compress, ENXIO, "this codec is not supported"); return false; } if (config->fragment_size < caps->min_fragment_size) { oops(compress, EINVAL, "requested fragment size %d is below min supported %d", config->fragment_size, caps->min_fragment_size); return false; } if (config->fragment_size > caps->max_fragment_size) { oops(compress, EINVAL, "requested fragment size %d is above max supported %d", config->fragment_size, caps->max_fragment_size); return false; } if (config->fragments < caps->min_fragments) { oops(compress, EINVAL, "requested fragments %d are below min supported %d", config->fragments, caps->min_fragments); return false; } if (config->fragments > caps->max_fragments) { oops(compress, EINVAL, "requested fragments %d are above max supported %d", config->fragments, caps->max_fragments); return false; } /* TODO: match the codec properties */ return true; } static bool _is_codec_type_supported(int fd, struct snd_codec *codec) { struct snd_compr_caps caps; bool found = false; unsigned int i; if (ioctl(fd, SNDRV_COMPRESS_GET_CAPS, &caps)) { oops(&bad_compress, errno, "cannot get device caps"); return false; } for (i = 0; i < caps.num_codecs; i++) { if (caps.codecs[i] == codec->id) { /* found the codec */ found = true; break; } } /* TODO: match the codec properties */ return found; } static inline void fill_compress_params(struct compr_config *config, struct snd_compr_params *params) { params->buffer.fragment_size = config->fragment_size; params->buffer.fragments = config->fragments; memcpy(¶ms->codec, config->codec, sizeof(params->codec)); } struct compress *compress_open(unsigned int card, unsigned int device, unsigned int flags, struct compr_config *config) { struct compress *compress; struct snd_compr_params params; struct snd_compr_caps caps; char fn[256]; if (!config) { oops(&bad_compress, EINVAL, "passed bad config"); return &bad_compress; } compress = calloc(1, sizeof(struct compress)); if (!compress) { oops(&bad_compress, errno, "cannot allocate compress object"); return &bad_compress; } compress->next_track = 0; compress->gapless_metadata = 0; compress->config = calloc(1, sizeof(*config)); if (!compress->config) goto input_fail; snprintf(fn, sizeof(fn), "/dev/snd/comprC%uD%u", card, device); compress->max_poll_wait_ms = DEFAULT_MAX_POLL_WAIT_MS; compress->flags = flags; if (!((flags & COMPRESS_OUT) || (flags & COMPRESS_IN))) { oops(&bad_compress, EINVAL, "can't deduce device direction from given flags"); goto config_fail; } if (flags & COMPRESS_OUT) { compress->fd = open(fn, O_RDONLY); } else { compress->fd = open(fn, O_WRONLY); } if (compress->fd < 0) { oops(&bad_compress, errno, "cannot open device '%s'", fn); goto config_fail; } if (ioctl(compress->fd, SNDRV_COMPRESS_GET_CAPS, &caps)) { oops(compress, errno, "cannot get device caps"); goto codec_fail; } /* If caller passed "don't care" fill in default values */ if ((config->fragment_size == 0) || (config->fragments == 0)) { config->fragment_size = caps.min_fragment_size; config->fragments = caps.max_fragments; } #if 0 /* FIXME need to turn this On when DSP supports * and treat in no support case */ if (_is_codec_supported(compress, config, &caps) == false) { oops(compress, errno, "codec not supported\n"); goto codec_fail; } #endif memcpy(compress->config, config, sizeof(*compress->config)); fill_compress_params(config, ¶ms); if (ioctl(compress->fd, SNDRV_COMPRESS_SET_PARAMS, ¶ms)) { oops(&bad_compress, errno, "cannot set device"); goto codec_fail; } return compress; codec_fail: close(compress->fd); compress->fd = -1; config_fail: free(compress->config); input_fail: free(compress); return &bad_compress; } void compress_close(struct compress *compress) { if (compress == &bad_compress) return; if (compress->fd >= 0) close(compress->fd); compress->running = 0; compress->fd = -1; free(compress->config); free(compress); } int compress_get_hpointer(struct compress *compress, unsigned int *avail, struct timespec *tstamp) { struct snd_compr_avail kavail; __u64 time; if (!is_compress_ready(compress)) return oops(compress, ENODEV, "device not ready"); if (ioctl(compress->fd, SNDRV_COMPRESS_AVAIL, &kavail)) return oops(compress, errno, "cannot get avail"); if (0 == kavail.tstamp.sampling_rate) return oops(compress, ENODATA, "sample rate unknown"); *avail = (unsigned int)kavail.avail; time = kavail.tstamp.pcm_io_frames / kavail.tstamp.sampling_rate; tstamp->tv_sec = time; time = kavail.tstamp.pcm_io_frames % kavail.tstamp.sampling_rate; tstamp->tv_nsec = time * 1000000000 / kavail.tstamp.sampling_rate; return 0; } int compress_get_tstamp(struct compress *compress, unsigned long *samples, unsigned int *sampling_rate) { struct snd_compr_tstamp ktstamp; if (!is_compress_ready(compress)) return oops(compress, ENODEV, "device not ready"); if (ioctl(compress->fd, SNDRV_COMPRESS_TSTAMP, &ktstamp)) return oops(compress, errno, "cannot get tstamp"); *samples = ktstamp.pcm_io_frames; *sampling_rate = ktstamp.sampling_rate; return 0; } int compress_write(struct compress *compress, const void *buf, unsigned int size) { struct snd_compr_avail avail; struct pollfd fds; int to_write = 0; /* zero indicates we haven't written yet */ int written, total = 0, ret; const char* cbuf = buf; const unsigned int frag_size = compress->config->fragment_size; if (!(compress->flags & COMPRESS_IN)) return oops(compress, EINVAL, "Invalid flag set"); if (!is_compress_ready(compress)) return oops(compress, ENODEV, "device not ready"); fds.fd = compress->fd; fds.events = POLLOUT; /*TODO: treat auto start here first */ while (size) { if (ioctl(compress->fd, SNDRV_COMPRESS_AVAIL, &avail)) return oops(compress, errno, "cannot get avail"); /* We can write if we have at least one fragment available * or there is enough space for all remaining data */ if ((avail.avail < frag_size) && (avail.avail < size)) { if (compress->nonblocking) return total; ret = poll(&fds, 1, compress->max_poll_wait_ms); if (fds.revents & POLLERR) { return oops(compress, EIO, "poll returned error!"); } /* A pause will cause -EBADFD or zero. * This is not an error, just stop writing */ if ((ret == 0) || (ret == -EBADFD)) break; if (ret < 0) return oops(compress, errno, "poll error"); if (fds.revents & POLLOUT) { continue; } } /* write avail bytes */ if (size > avail.avail) to_write = avail.avail; else to_write = size; written = write(compress->fd, cbuf, to_write); /* If play was paused the write returns -EBADFD */ if (written == -EBADFD) break; if (written < 0) return oops(compress, errno, "write failed!"); size -= written; cbuf += written; total += written; } return total; } int compress_read(struct compress *compress, void *buf, unsigned int size) { struct snd_compr_avail avail; struct pollfd fds; int to_read = 0; int num_read, total = 0, ret; char* cbuf = buf; const unsigned int frag_size = compress->config->fragment_size; if (!(compress->flags & COMPRESS_OUT)) return oops(compress, EINVAL, "Invalid flag set"); if (!is_compress_ready(compress)) return oops(compress, ENODEV, "device not ready"); fds.fd = compress->fd; fds.events = POLLIN; while (size) { if (ioctl(compress->fd, SNDRV_COMPRESS_AVAIL, &avail)) return oops(compress, errno, "cannot get avail"); if ( (avail.avail < frag_size) && (avail.avail < size) ) { /* Less than one fragment available and not at the * end of the read, so poll */ if (compress->nonblocking) return total; ret = poll(&fds, 1, compress->max_poll_wait_ms); if (fds.revents & POLLERR) { return oops(compress, EIO, "poll returned error!"); } /* A pause will cause -EBADFD or zero. * This is not an error, just stop reading */ if ((ret == 0) || (ret == -EBADFD)) break; if (ret < 0) return oops(compress, errno, "poll error"); if (fds.revents & POLLIN) { continue; } } /* read avail bytes */ if (size > avail.avail) to_read = avail.avail; else to_read = size; num_read = read(compress->fd, cbuf, to_read); /* If play was paused the read returns -EBADFD */ if (num_read == -EBADFD) break; if (num_read < 0) return oops(compress, errno, "read failed!"); size -= num_read; cbuf += num_read; total += num_read; } return total; } int compress_start(struct compress *compress) { if (!is_compress_ready(compress)) return oops(compress, ENODEV, "device not ready"); if (ioctl(compress->fd, SNDRV_COMPRESS_START)) return oops(compress, errno, "cannot start the stream"); compress->running = 1; return 0; } int compress_stop(struct compress *compress) { if (!is_compress_running(compress)) return oops(compress, ENODEV, "device not ready"); if (ioctl(compress->fd, SNDRV_COMPRESS_STOP)) return oops(compress, errno, "cannot stop the stream"); return 0; } int compress_pause(struct compress *compress) { if (!is_compress_running(compress)) return oops(compress, ENODEV, "device not ready"); if (ioctl(compress->fd, SNDRV_COMPRESS_PAUSE)) return oops(compress, errno, "cannot pause the stream"); return 0; } int compress_resume(struct compress *compress) { if (ioctl(compress->fd, SNDRV_COMPRESS_RESUME)) return oops(compress, errno, "cannot resume the stream"); return 0; } int compress_drain(struct compress *compress) { if (!is_compress_running(compress)) return oops(compress, ENODEV, "device not ready"); if (ioctl(compress->fd, SNDRV_COMPRESS_DRAIN)) return oops(compress, errno, "cannot drain the stream"); return 0; } int compress_partial_drain(struct compress *compress) { if (!is_compress_running(compress)) return oops(compress, ENODEV, "device not ready"); if (!compress->next_track) return oops(compress, EPERM, "next track not signalled"); if (ioctl(compress->fd, SNDRV_COMPRESS_PARTIAL_DRAIN)) return oops(compress, errno, "cannot drain the stream\n"); compress->next_track = 0; return 0; } int compress_next_track(struct compress *compress) { if (!is_compress_running(compress)) return oops(compress, ENODEV, "device not ready"); if (!compress->gapless_metadata) return oops(compress, EPERM, "metadata not set"); if (ioctl(compress->fd, SNDRV_COMPRESS_NEXT_TRACK)) return oops(compress, errno, "cannot set next track\n"); compress->next_track = 1; compress->gapless_metadata = 0; return 0; } int compress_set_gapless_metadata(struct compress *compress, struct compr_gapless_mdata *mdata) { struct snd_compr_metadata metadata; int version; if (!is_compress_ready(compress)) return oops(compress, ENODEV, "device not ready"); version = get_compress_version(compress); if (version <= 0) return -1; if (version < SNDRV_PROTOCOL_VERSION(0, 1, 1)) return oops(compress, ENXIO, "gapless apis not supported in kernel"); metadata.key = SNDRV_COMPRESS_ENCODER_PADDING; metadata.value[0] = mdata->encoder_padding; if (ioctl(compress->fd, SNDRV_COMPRESS_SET_METADATA, &metadata)) return oops(compress, errno, "can't set metadata for stream\n"); metadata.key = SNDRV_COMPRESS_ENCODER_DELAY; metadata.value[0] = mdata->encoder_delay; if (ioctl(compress->fd, SNDRV_COMPRESS_SET_METADATA, &metadata)) return oops(compress, errno, "can't set metadata for stream\n"); compress->gapless_metadata = 1; return 0; } bool is_codec_supported(unsigned int card, unsigned int device, unsigned int flags, struct snd_codec *codec) { unsigned int dev_flag; bool ret; int fd; char fn[256]; snprintf(fn, sizeof(fn), "/dev/snd/comprC%uD%u", card, device); if (flags & COMPRESS_OUT) dev_flag = O_RDONLY; else dev_flag = O_WRONLY; fd = open(fn, dev_flag); if (fd < 0) return oops(&bad_compress, errno, "cannot open device '%s'", fn); ret = _is_codec_type_supported(fd, codec); close(fd); return ret; } void compress_set_max_poll_wait(struct compress *compress, int milliseconds) { compress->max_poll_wait_ms = milliseconds; } void compress_nonblock(struct compress *compress, int nonblock) { compress->nonblocking = !!nonblock; } int compress_wait(struct compress *compress, int timeout_ms) { struct pollfd fds; int ret; fds.fd = compress->fd; fds.events = POLLOUT | POLLIN; ret = poll(&fds, 1, timeout_ms); if (ret > 0) { if (fds.revents & POLLERR) return oops(compress, EIO, "poll returned error!"); if (fds.revents & (POLLOUT | POLLIN)) return 0; } if (ret == 0) return oops(compress, ETIME, "poll timed out"); if (ret < 0) return oops(compress, errno, "poll error"); return oops(compress, EIO, "poll signalled unhandled event"); }