327 lines
11 KiB
C
327 lines
11 KiB
C
/*
|
|
* BSD LICENSE
|
|
*
|
|
* Copyright (c) 2011-2012, Intel Corporation
|
|
* 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 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.
|
|
*/
|
|
|
|
|
|
#ifndef __TINYCOMPRESS_H
|
|
#define __TINYCOMPRESS_H
|
|
|
|
#if defined(__cplusplus)
|
|
extern "C" {
|
|
#endif
|
|
/*
|
|
* struct compr_config: config structure, needs to be filled by app
|
|
* If fragment_size or fragments are zero, this means "don't care"
|
|
* and tinycompress will choose values that the driver supports
|
|
*
|
|
* @fragment_size: size of fragment requested, in bytes
|
|
* @fragments: number of fragments
|
|
* @codec: codec type and parameters requested
|
|
*/
|
|
struct compr_config {
|
|
__u32 fragment_size;
|
|
__u32 fragments;
|
|
struct snd_codec *codec;
|
|
};
|
|
|
|
struct compr_gapless_mdata {
|
|
__u32 encoder_delay;
|
|
__u32 encoder_padding;
|
|
};
|
|
|
|
#define COMPRESS_OUT 0x20000000
|
|
#define COMPRESS_IN 0x10000000
|
|
|
|
struct compress;
|
|
struct snd_compr_tstamp;
|
|
|
|
#ifdef ENABLE_EXTENDED_COMPRESS_FORMAT
|
|
union snd_codec_options;
|
|
struct snd_compr_metadata;
|
|
#endif
|
|
/*
|
|
* compress_open: open a new compress stream
|
|
* returns the valid struct compress on success, NULL on failure
|
|
* If config does not specify a requested fragment size, on return
|
|
* it will be updated with the size and number of fragments that
|
|
* were configured
|
|
*
|
|
* @card: sound card number
|
|
* @device: device number
|
|
* @flags: device flags can be COMPRESS_OUT or COMPRESS_IN
|
|
* @config: stream config requested. Returns actual fragment config
|
|
*/
|
|
struct compress *compress_open(unsigned int card, unsigned int device,
|
|
unsigned int flags, struct compr_config *config);
|
|
|
|
/*
|
|
* compress_close: close the compress stream
|
|
*
|
|
* @compress: compress stream to be closed
|
|
*/
|
|
void compress_close(struct compress *compress);
|
|
|
|
/*
|
|
* compress_get_hpointer: get the hw timestamp
|
|
* return 0 on success, negative on error
|
|
*
|
|
* @compress: compress stream on which query is made
|
|
* @avail: buffer availble for write/read, in bytes
|
|
* @tstamp: hw time
|
|
*/
|
|
int compress_get_hpointer(struct compress *compress,
|
|
unsigned int *avail, struct timespec *tstamp);
|
|
|
|
|
|
/*
|
|
* compress_get_tstamp: get the raw hw timestamp
|
|
* return 0 on success, negative on error
|
|
*
|
|
* @compress: compress stream on which query is made
|
|
* @samples: number of decoded samples played
|
|
* @sampling_rate: sampling rate of decoded samples
|
|
*/
|
|
int compress_get_tstamp(struct compress *compress,
|
|
unsigned long *samples, unsigned int *sampling_rate);
|
|
|
|
/*
|
|
* compress_write: write data to the compress stream
|
|
* return bytes written on success, negative on error
|
|
* By default this is a blocking call and will not return
|
|
* until all bytes have been written or there was a
|
|
* write error.
|
|
* If non-blocking mode has been enabled with compress_nonblock(),
|
|
* this function will write all bytes that can be written without
|
|
* blocking and will then return the number of bytes successfully
|
|
* written. If the return value is not an error and is < size
|
|
* the caller can use compress_wait() to block until the driver
|
|
* is ready for more data.
|
|
*
|
|
* @compress: compress stream to be written to
|
|
* @buf: pointer to data
|
|
* @size: number of bytes to be written
|
|
*/
|
|
int compress_write(struct compress *compress, const void *buf, unsigned int size);
|
|
|
|
/*
|
|
* compress_read: read data from the compress stream
|
|
* return bytes read on success, negative on error
|
|
* By default this is a blocking call and will block until
|
|
* size bytes have been written or there was a read error.
|
|
* If non-blocking mode was enabled using compress_nonblock()
|
|
* the behaviour will change to read only as many bytes as
|
|
* are currently available (if no bytes are available it
|
|
* will return immediately). The caller can then use
|
|
* compress_wait() to block until more bytes are available.
|
|
*
|
|
* @compress: compress stream from where data is to be read
|
|
* @buf: pointer to data buffer
|
|
* @size: size of given buffer
|
|
*/
|
|
int compress_read(struct compress *compress, void *buf, unsigned int size);
|
|
|
|
/*
|
|
* compress_start: start the compress stream
|
|
* return 0 on success, negative on error
|
|
*
|
|
* @compress: compress stream to be started
|
|
*/
|
|
int compress_start(struct compress *compress);
|
|
|
|
/*
|
|
* compress_stop: stop the compress stream
|
|
* return 0 on success, negative on error
|
|
*
|
|
* @compress: compress stream to be stopped
|
|
*/
|
|
int compress_stop(struct compress *compress);
|
|
|
|
/*
|
|
* compress_pause: pause the compress stream
|
|
* return 0 on success, negative on error
|
|
*
|
|
* @compress: compress stream to be paused
|
|
*/
|
|
int compress_pause(struct compress *compress);
|
|
|
|
/*
|
|
* compress_resume: resume the compress stream
|
|
* return 0 on success, negative on error
|
|
*
|
|
* @compress: compress stream to be resumed
|
|
*/
|
|
int compress_resume(struct compress *compress);
|
|
|
|
/*
|
|
* compress_drain: drain the compress stream
|
|
* return 0 on success, negative on error
|
|
*
|
|
* @compress: compress stream to be drain
|
|
*/
|
|
int compress_drain(struct compress *compress);
|
|
|
|
/*
|
|
* compress_next_track: set the next track for stream
|
|
*
|
|
* return 0 on success, negative on error
|
|
*
|
|
* @compress: compress stream to be transistioned to next track
|
|
*/
|
|
int compress_next_track(struct compress *compress);
|
|
|
|
/*
|
|
* compress_partial_drain: drain will return after the last frame is decoded
|
|
* by DSP and will play the , All the data written into compressed
|
|
* ring buffer is decoded
|
|
*
|
|
* return 0 on success, negative on error
|
|
*
|
|
* @compress: compress stream to be drain
|
|
*/
|
|
int compress_partial_drain(struct compress *compress);
|
|
|
|
/*
|
|
* compress_set_gapless_metadata: set gapless metadata of a compress strem
|
|
*
|
|
* return 0 on success, negative on error
|
|
*
|
|
* @compress: compress stream for which metadata has to set
|
|
* @mdata: metadata encoder delay and padding
|
|
*/
|
|
|
|
int compress_set_gapless_metadata(struct compress *compress,
|
|
struct compr_gapless_mdata *mdata);
|
|
|
|
#ifdef ENABLE_EXTENDED_COMPRESS_FORMAT
|
|
/*
|
|
* compress_set_next_track_param: set params of next compress stream in gapless
|
|
*
|
|
* return 0 on success, negative on error
|
|
*
|
|
* @compress: compress stream for which codec options has to be set
|
|
* @codec_options: codec options of compress stream based on codec type
|
|
*/
|
|
|
|
int compress_set_next_track_param(struct compress *compress,
|
|
union snd_codec_options *codec_options);
|
|
#endif
|
|
|
|
/*
|
|
* is_codec_supported:check if the given codec is supported
|
|
* returns true when supported, false if not
|
|
*
|
|
* @card: sound card number
|
|
* @device: device number
|
|
* @flags: stream flags
|
|
* @codec: codec type and parameters to be checked
|
|
*/
|
|
bool is_codec_supported(unsigned int card, unsigned int device,
|
|
unsigned int flags, struct snd_codec *codec);
|
|
|
|
/*
|
|
* compress_set_max_poll_wait: set the maximum time tinycompress
|
|
* will wait for driver to signal a poll(). Interval is in
|
|
* milliseconds.
|
|
* Pass interval of -1 to disable timeout and make poll() wait
|
|
* until driver signals.
|
|
* If this function is not used the timeout defaults to 20 seconds.
|
|
*/
|
|
void compress_set_max_poll_wait(struct compress *compress, int milliseconds);
|
|
|
|
/* Enable or disable non-blocking mode for write and read */
|
|
void compress_nonblock(struct compress *compress, int nonblock);
|
|
|
|
/* Wait for ring buffer to ready for next read or write */
|
|
int compress_wait(struct compress *compress, int timeout_ms);
|
|
|
|
int is_compress_running(struct compress *compress);
|
|
|
|
int is_compress_ready(struct compress *compress);
|
|
|
|
/* Returns a human readable reason for the last error */
|
|
const char *compress_get_error(struct compress *compress);
|
|
/*
|
|
* since the SNDRV_PCM_RATE_* is not availble anywhere in userspace
|
|
* and we have used these to define the sampling rate, we need to define
|
|
* then here
|
|
*/
|
|
#define SNDRV_PCM_RATE_5512 (1<<0) /* 5512Hz */
|
|
#define SNDRV_PCM_RATE_8000 (1<<1) /* 8000Hz */
|
|
#define SNDRV_PCM_RATE_11025 (1<<2) /* 11025Hz */
|
|
#define SNDRV_PCM_RATE_16000 (1<<3) /* 16000Hz */
|
|
#define SNDRV_PCM_RATE_22050 (1<<4) /* 22050Hz */
|
|
#define SNDRV_PCM_RATE_32000 (1<<5) /* 32000Hz */
|
|
#define SNDRV_PCM_RATE_44100 (1<<6) /* 44100Hz */
|
|
#define SNDRV_PCM_RATE_48000 (1<<7) /* 48000Hz */
|
|
#define SNDRV_PCM_RATE_64000 (1<<8) /* 64000Hz */
|
|
#define SNDRV_PCM_RATE_88200 (1<<9) /* 88200Hz */
|
|
#define SNDRV_PCM_RATE_96000 (1<<10) /* 96000Hz */
|
|
#define SNDRV_PCM_RATE_176400 (1<<11) /* 176400Hz */
|
|
#define SNDRV_PCM_RATE_192000 (1<<12) /* 192000Hz */
|
|
|
|
/* utility functions */
|
|
unsigned int compress_get_alsa_rate(unsigned int rate);
|
|
|
|
#ifdef ENABLE_EXTENDED_COMPRESS_FORMAT
|
|
/* set metadata */
|
|
int compress_set_metadata(struct compress *compress,
|
|
struct snd_compr_metadata *mdata);
|
|
|
|
/* get metadata */
|
|
int compress_get_metadata(struct compress *compress,
|
|
struct snd_compr_metadata *mdata);
|
|
#endif
|
|
|
|
#if defined(__cplusplus)
|
|
}
|
|
#endif
|
|
|
|
#endif
|