wine/gecko
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/wine-gecko.git synced 2024-09-13 09:24:08 -07:00
Code Issues Packages Projects Releases Wiki Activity
74338296c8
gecko/media/libsydneyaudio/include/sydney_audio.h

462 lines
15 KiB
C
Raw Blame History

#ifndef foosydneyhfoo
#define foosydneyhfoo
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Initial Developer of the Original Code is
* CSIRO
* Portions created by the Initial Developer are Copyright (C) 2007
* the Initial Developer. All Rights Reserved.
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** *
*/
/* Requirements:
- In sync mode, the device will automatically write data so that an initial read causes writes
of zeros to be issued to that one can do "while (1); {read(); write()}
- All functions are thread-safe and can be called in any thread context. None of the functions is
async-signal safe.
- It is assumed that duplex streams have a single clock (synchronised)
*/
#include <sys/types.h>
#if !defined (WIN32)
#include <sys/param.h>
#include <inttypes.h>
#if defined(__FreeBSD__)
#include <sys/endian.h>
#endif
#else
#include <stddef.h>
#endif
/* Detect byte order, based on sys/param.h */
#undef SA_LITTLE_ENDIAN
#undef SA_BIG_ENDIAN
#if defined(__BYTE_ORDER)
# if __BYTE_ORDER == __LITTLE_ENDIAN
# define SA_LITTLE_ENDIAN 1
# elif __BYTE_ORDER == __BIG_ENDIAN
# define SA_BIG_ENDIAN 1
# endif
#elif defined(_BYTE_ORDER)
# if _BYTE_ORDER == _LITTLE_ENDIAN
# define SA_LITTLE_ENDIAN 1
# elif _BYTE_ORDER == _BIG_ENDIAN
# define SA_BIG_ENDIAN 1
# endif
#elif defined(WIN32)
# define SA_LITTLE_ENDIAN 1
#elif defined(__APPLE__)
# if defined(__BIG_ENDIAN__)
# define SA_BIG_ENDIAN 1
# else
# define SA_LITTLE_ENDIAN 1
# endif
#elif defined(SOLARIS)
# if defined(_BIG_ENDIAN)
# define SA_BIG_ENDIAN 1
# else
# define SA_LITTLE_ENDIAN 1
# endif
#else
# error "Cannot determine byte order!"
#endif
#if defined(WIN32)
#if !defined(int32_t)
typedef __int32 int32_t;
#endif
#if !defined(int64_t)
typedef __int64 int64_t;
#endif
#endif
typedef struct sa_stream sa_stream_t;
#if defined(WIN32)
// (left << 16 | right) (16 bits per channel)
#define SA_VOLUME_MUTED ((int32_t) (0x00000000))
#else
/** Volume that corresponds to muted in/out */
#define SA_VOLUME_MUTED ((int32_t) (-0x80000000))
#endif
/** Ways to express seek offsets for pread/pwrite */
typedef enum {
SA_SEEK_RELATIVE,
SA_SEEK_ABSOLUTE,
SA_SEEK_RELATIVE_END,
_SA_SEEK_MAX
} sa_seek_t;
/** Supported formats */
typedef enum {
SA_PCM_FORMAT_U8,
SA_PCM_FORMAT_ULAW,
SA_PCM_FORMAT_ALAW,
SA_PCM_FORMAT_S16_LE,
SA_PCM_FORMAT_S16_BE,
SA_PCM_FORMAT_S24_LE,
SA_PCM_FORMAT_S24_BE,
SA_PCM_FORMAT_S32_LE,
SA_PCM_FORMAT_S32_BE,
SA_PCM_FORMAT_FLOAT32_LE,
SA_PCM_FORMAT_FLOAT32_BE,
_SA_PCM_FORMAT_MAX
} sa_pcm_format_t;
/* Native/reverse endianness definitions for PCM */
#ifdef SA_LITTLE_ENDIAN
#define SA_PCM_FORMAT_S16_NE SA_PCM_FORMAT_S16_LE
#define SA_PCM_FORMAT_S24_NE SA_PCM_FORMAT_S24_LE
#define SA_PCM_FORMAT_S32_NE SA_PCM_FORMAT_S32_LE
#define SA_PCM_FORMAT_FLOAT32_NE SA_PCM_FORMAT_FLOAT32_LE
#define SA_PCM_FORMAT_S16_RE SA_PCM_FORMAT_S16_BE
#define SA_PCM_FORMAT_S24_RE SA_PCM_FORMAT_S24_BE
#define SA_PCM_FORMAT_S32_RE SA_PCM_FORMAT_S32_BE
#define SA_PCM_FORMAT_FLOAT32_RE SA_PCM_FORMAT_FLOAT32_BE
#else
#define SA_PCM_FORMAT_S16_NE SA_PCM_FORMAT_S16_BE
#define SA_PCM_FORMAT_S24_NE SA_PCM_FORMAT_S24_BE
#define SA_PCM_FORMAT_S32_NE SA_PCM_FORMAT_S32_BE
#define SA_PCM_FORMAT_FLOAT32_NE SA_PCM_FORMAT_FLOAT32_BE
#define SA_PCM_FORMAT_S16_RE SA_PCM_FORMAT_S16_LE
#define SA_PCM_FORMAT_S24_RE SA_PCM_FORMAT_S24_LE
#define SA_PCM_FORMAT_S32_RE SA_PCM_FORMAT_S32_LE
#define SA_PCM_FORMAT_FLOAT32_RE SA_PCM_FORMAT_FLOAT32_LE
#endif
#define SA_CODEC_MPEG "mpeg"
#define SA_CODEC_AC3 "ac3"
#define SA_CODEC_GSM "gsm"
#define SA_CODEC_VORBIS "vorbis"
#define SA_CODEC_SPEEX "speex"
/** Device opening modes */
typedef enum {
SA_MODE_WRONLY = 1,
SA_MODE_RDONLY = 2,
SA_MODE_RDWR = 3,
_SA_MODE_MAX = 4
} sa_mode_t;
/** Error codes */
typedef enum {
SA_SUCCESS = 0,
SA_ERROR_NOT_SUPPORTED = -1,
SA_ERROR_INVALID = -2,
SA_ERROR_STATE = -3,
SA_ERROR_OOM = -4,
SA_ERROR_NO_DEVICE = -5,
SA_ERROR_NO_DRIVER = -6,
SA_ERROR_NO_CODEC = -7,
SA_ERROR_NO_PCM_FORMAT = -7,
SA_ERROR_SYSTEM = -8,
SA_ERROR_NO_INIT = -9,
SA_ERROR_NO_META = -10,
SA_ERROR_NO_DATA = -11,
SA_ERROR_NO_SPACE = -12,
_SA_ERROR_MAX = -13
} sa_error_t;
/** Possible events for notifications */
typedef enum {
SA_NOTIFY_REQUEST_START,
SA_NOTIFY_REQUEST_STOP,
SA_NOTIFY_CHANGED_READ_VOLUME,
SA_NOTIFY_CHANGED_WRITE_VOLUME,
SA_NOTIFY_CHANGED_DEVICE,
_SA_NOTIFY_MAX
} sa_notify_t;
/** Classes of events */
typedef enum {
SA_EVENT_REQUEST_IO,
SA_EVENT_INIT_THREAD,
SA_EVENT_NOTIFY,
SA_EVENT_ERROR,
_SA_EVENT_MAX
} sa_event_t;
/** List of sample position queries */
typedef enum {
SA_POSITION_WRITE_DELAY,
SA_POSITION_WRITE_HARDWARE,
SA_POSITION_WRITE_SOFTWARE,
SA_POSITION_READ_DELAY,
SA_POSITION_READ_HARDWARE,
SA_POSITION_READ_SOFTWARE,
SA_POSITION_DUPLEX_DELAY,
_SA_POSITION_MAX
} sa_position_t;
/* Channel positions */
typedef enum {
SA_CHANNEL_MONO,
SA_CHANNEL_LEFT,
SA_CHANNEL_RIGHT,
SA_CHANNEL_CENTER,
SA_CHANNEL_FRONT_LEFT,
SA_CHANNEL_FRONT_RIGHT,
SA_CHANNEL_FRONT_CENTER,
SA_CHANNEL_REAR_LEFT,
SA_CHANNEL_REAR_RIGHT,
SA_CHANNEL_REAR_CENTER,
SA_CHANNEL_LFE,
SA_CHANNEL_FRONT_LEFT_OF_CENTER,
SA_CHANNEL_FRONT_RIGHT_OF_CENTER,
SA_CHANNEL_SIDE_LEFT,
SA_CHANNEL_SIDE_RIGHT,
SA_CHANNEL_TOP_CENTER,
SA_CHANNEL_TOP_FRONT_LEFT,
SA_CHANNEL_TOP_FRONT_RIGHT,
SA_CHANNEL_TOP_FRONT_CENTER,
SA_CHANNEL_TOP_REAR_LEFT,
SA_CHANNEL_TOP_REAR_RIGHT,
SA_CHANNEL_TOP_REAR_CENTER,
SA_CHANNEL_AUX0,
SA_CHANNEL_AUX1,
SA_CHANNEL_AUX2,
SA_CHANNEL_AUX3,
SA_CHANNEL_AUX4,
SA_CHANNEL_AUX5,
SA_CHANNEL_AUX6,
SA_CHANNEL_AUX7,
SA_CHANNEL_AUX8,
SA_CHANNEL_AUX9,
SA_CHANNEL_AUX10,
SA_CHANNEL_AUX11,
SA_CHANNEL_AUX12,
SA_CHANNEL_AUX13,
SA_CHANNEL_AUX14,
SA_CHANNEL_AUX15,
SA_CHANNEL_AUX16,
SA_CHANNEL_AUX17,
SA_CHANNEL_AUX18,
SA_CHANNEL_AUX19,
SA_CHANNEL_AUX20,
SA_CHANNEL_AUX21,
SA_CHANNEL_AUX22,
SA_CHANNEL_AUX23,
SA_CHANNEL_AUX24,
SA_CHANNEL_AUX25,
SA_CHANNEL_AUX26,
SA_CHANNEL_AUX27,
SA_CHANNEL_AUX28,
SA_CHANNEL_AUX29,
SA_CHANNEL_AUX30,
SA_CHANNEL_AUX31,
_SA_CHANNEL_MAX
} sa_channel_t;
typedef enum {
SA_STATE_INIT,
SA_STATE_RUNNING,
SA_STATE_STOPPED,
/* put more stuff */
_SA_STATE_MAX
} sa_state_t;
typedef enum {
SA_XRUN_MODE_STOP,
SA_XRUN_MODE_SPIN,
_SA_XRUN_MODE_MAX
} sa_xrun_mode_t;
typedef enum {
SA_ADJUST_UP = 1,
SA_ADJUST_DOWN = -1,
SA_ADJUST_NONE = 0
} sa_adjust_t;
/* Some kind of meta information. */
#define SA_META_CLIENT_NAME "sydney.client-name" /* utf-8 */
#define SA_META_PROCESS_ID "sydney.process-id" /* getpid() */
#define SA_META_LANGUAGE "sydney.language" /* de_DE and similar */
/* Some kind of meta information. Not filled in */
#define SA_META_STREAM_NAME "sydney.stream-name" /* utf-8 */
#define SA_META_ICON_NAME "sydney.icon-name" /* file name (no slashes) */
#define SA_META_ICON_PNG "sydney.icon-png" /* PNG blob */
#define SA_META_ROLE "sydney.role" /* one of: "music", "phone", "game", "event" */
#define SA_META_X11_DISPLAY "sydney.x11-display" /* X11 display */
#define SA_META_X11_WINDOW "sydney.x11-window" /* X11 window id */
/** Main callback function */
typedef int (*sa_event_callback_t)(sa_stream_t *s, sa_event_t event);
/** Create an opaque (e.g. AC3) codec stream */
int sa_stream_create_opaque(sa_stream_t **s, const char *client_name, sa_mode_t mode, const char *codec);
/** Normal way to open a PCM device */
int sa_stream_create_pcm(sa_stream_t **s, const char *client_name, sa_mode_t mode, sa_pcm_format_t format, unsigned int rate, unsigned int nchannels);
/** Initialise the device */
int sa_stream_open(sa_stream_t *s);
/** Close/destroy everything */
int sa_stream_destroy(sa_stream_t *s);
/* "Soft" params */
int sa_stream_set_write_lower_watermark(sa_stream_t *s, size_t size);
int sa_stream_set_read_lower_watermark(sa_stream_t *s, size_t size);
int sa_stream_set_write_upper_watermark(sa_stream_t *s, size_t size);
int sa_stream_set_read_upper_watermark(sa_stream_t *s, size_t size);
/** Set the mapping between channels and the loudspeakers */
int sa_stream_set_channel_map(sa_stream_t *s, const sa_channel_t map[], unsigned int n);
/** Whether xruns cause the card to reset */
int sa_stream_set_xrun_mode(sa_stream_t *s, sa_xrun_mode_t mode);
/** Set the device to non-interleaved mode */
int sa_stream_set_non_interleaved(sa_stream_t *s, int enable);
/** Require dynamic sample rate */
int sa_stream_set_dynamic_rate(sa_stream_t *s, int enable);
/** Select driver */
int sa_stream_set_driver(sa_stream_t *s, const char *driver);
/** Start callback */
int sa_stream_start_thread(sa_stream_t *s, sa_event_callback_t callback);
/** Start callback */
int sa_stream_stop_thread(sa_stream_t *s);
/** Change the device connected to the stream */
int sa_stream_change_device(sa_stream_t *s, const char *device_name);
/** volume in hundreths of dB*/
int sa_stream_change_read_volume(sa_stream_t *s, const int32_t vol[], unsigned int n);
/** volume in hundreths of dB*/
int sa_stream_change_write_volume(sa_stream_t *s, const int32_t vol[], unsigned int n);
/** Change the sampling rate */
int sa_stream_change_rate(sa_stream_t *s, unsigned int rate);
/** Change some meta data that is attached to the stream */
int sa_stream_change_meta_data(sa_stream_t *s, const char *name, const void *data, size_t size);
/** Associate opaque user data */
int sa_stream_change_user_data(sa_stream_t *s, const void *value);
/* Hardware-related. This is implementation-specific and hardware specific. */
int sa_stream_set_adjust_rate(sa_stream_t *s, sa_adjust_t direction);
int sa_stream_set_adjust_nchannels(sa_stream_t *s, sa_adjust_t direction);
int sa_stream_set_adjust_pcm_format(sa_stream_t *s, sa_adjust_t direction);
int sa_stream_set_adjust_watermarks(sa_stream_t *s, sa_adjust_t direction);
/* Query functions */
int sa_stream_get_mode(sa_stream_t *s, sa_mode_t *access_mode);
int sa_stream_get_codec(sa_stream_t *s, char *codec, size_t *size);
int sa_stream_get_pcm_format(sa_stream_t *s, sa_pcm_format_t *format);
int sa_stream_get_rate(sa_stream_t *s, unsigned int *rate);
int sa_stream_get_nchannels(sa_stream_t *s, int *nchannels);
int sa_stream_get_user_data(sa_stream_t *s, void **value);
int sa_stream_get_write_lower_watermark(sa_stream_t *s, size_t *size);
int sa_stream_get_read_lower_watermark(sa_stream_t *s, size_t *size);
int sa_stream_get_write_upper_watermark(sa_stream_t *s, size_t *size);
int sa_stream_get_read_upper_watermark(sa_stream_t *s, size_t *size);
int sa_stream_get_channel_map(sa_stream_t *s, sa_channel_t map[], unsigned int *n);
int sa_stream_get_xrun_mode(sa_stream_t *s, sa_xrun_mode_t *mode);
int sa_stream_get_non_interleaved(sa_stream_t *s, int *enabled);
int sa_stream_get_dynamic_rate(sa_stream_t *s, int *enabled);
int sa_stream_get_driver(sa_stream_t *s, char *driver_name, size_t *size);
int sa_stream_get_device(sa_stream_t *s, char *device_name, size_t *size);
int sa_stream_get_read_volume(sa_stream_t *s, int32_t vol[], unsigned int *n);
int sa_stream_get_write_volume(sa_stream_t *s, int32_t vol[], unsigned int *n);
int sa_stream_get_meta_data(sa_stream_t *s, const char *name, void*data, size_t *size);
int sa_stream_get_adjust_rate(sa_stream_t *s, sa_adjust_t *direction);
int sa_stream_get_adjust_nchannels(sa_stream_t *s, sa_adjust_t *direction);
int sa_stream_get_adjust_pcm_format(sa_stream_t *s, sa_adjust_t *direction);
int sa_stream_get_adjust_watermarks(sa_stream_t *s, sa_adjust_t *direction);
/** Get current state of the audio device */
int sa_stream_get_state(sa_stream_t *s, sa_state_t *state);
/** Obtain the error code */
int sa_stream_get_event_error(sa_stream_t *s, sa_error_t *error);
/** Obtain the notification code */
int sa_stream_get_event_notify(sa_stream_t *s, sa_notify_t *notify);
/** sync/timing */
int sa_stream_get_position(sa_stream_t *s, sa_position_t position, int64_t *pos);
/* Blocking IO calls */
/** Interleaved capture function */
int sa_stream_read(sa_stream_t *s, void *data, size_t nbytes);
/** Non-interleaved capture function */
int sa_stream_read_ni(sa_stream_t *s, unsigned int channel, void *data, size_t nbytes);
/** Interleaved playback function */
int sa_stream_write(sa_stream_t *s, const void *data, size_t nbytes);
/** Non-interleaved playback function */
int sa_stream_write_ni(sa_stream_t *s, unsigned int channel, const void *data, size_t nbytes);
/** Interleaved playback function with seek offset */
int sa_stream_pwrite(sa_stream_t *s, const void *data, size_t nbytes, int64_t offset, sa_seek_t whence);
/** Non-interleaved playback function with seek offset */
int sa_stream_pwrite_ni(sa_stream_t *s, unsigned int channel, const void *data, size_t nbytes, int64_t offset, sa_seek_t whence);
/** Query how much can be read without blocking */
int sa_stream_get_read_size(sa_stream_t *s, size_t *size);
/** Query how much can be written without blocking */
int sa_stream_get_write_size(sa_stream_t *s, size_t *size);
/* Control/xrun */
/** Resume playing after a pause */
int sa_stream_resume(sa_stream_t *s);
/** Pause audio playback (do not empty the buffer) */
int sa_stream_pause(sa_stream_t *s);
/** Block until all audio has been played */
int sa_stream_drain(sa_stream_t *s);
/** Return a human readable error */
const char *sa_strerror(int code);
/* Extensions */
int
sa_stream_set_volume_abs(sa_stream_t *s, float vol);
int
sa_stream_get_volume_abs(sa_stream_t *s, float *vol);
#endif
Reference in New Issue View Git Blame Copy Permalink