From 6ac77bc180fbd985988015020c2e2347e802959d Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Thu, 17 Nov 2005 14:01:49 +0100 Subject: [ALSA] Remove xxx_t typedefs: PCM OSS-emulation Modules: ALSA<-OSS emulation Remove xxx_t typedefs from the core PCM OSS-emulation codes. Signed-off-by: Takashi Iwai --- include/sound/pcm_oss.h | 41 +++-- sound/core/oss/copy.c | 16 +- sound/core/oss/io.c | 28 ++-- sound/core/oss/linear.c | 38 ++--- sound/core/oss/mulaw.c | 54 +++---- sound/core/oss/pcm_oss.c | 364 ++++++++++++++++++++++---------------------- sound/core/oss/pcm_plugin.c | 110 ++++++------- sound/core/oss/pcm_plugin.h | 208 +++++++++++++------------ sound/core/oss/rate.c | 83 +++++----- sound/core/oss/route.c | 134 ++++++++-------- 10 files changed, 543 insertions(+), 533 deletions(-) diff --git a/include/sound/pcm_oss.h b/include/sound/pcm_oss.h index 0b67c9d105af..fddaddde47b4 100644 --- a/include/sound/pcm_oss.h +++ b/include/sound/pcm_oss.h @@ -22,10 +22,7 @@ * */ -typedef struct _snd_pcm_plugin snd_pcm_plugin_t; -typedef struct _snd_pcm_oss_setup snd_pcm_oss_setup_t; - -struct _snd_pcm_oss_setup { +struct snd_pcm_oss_setup { char *task_name; unsigned int disable:1, direct:1, @@ -36,10 +33,10 @@ struct _snd_pcm_oss_setup { buggyptr:1; unsigned int periods; unsigned int period_size; - snd_pcm_oss_setup_t *next; + struct snd_pcm_oss_setup *next; }; -typedef struct _snd_pcm_oss_runtime { +struct snd_pcm_oss_runtime { unsigned params: 1, /* format/parameter change */ prepare: 1, /* need to prepare the operation */ trigger: 1, /* trigger flag */ @@ -59,30 +56,30 @@ typedef struct _snd_pcm_oss_runtime { size_t mmap_bytes; char *buffer; /* vmallocated period */ size_t buffer_used; /* used length from period buffer */ - snd_pcm_plugin_t *plugin_first; - snd_pcm_plugin_t *plugin_last; + struct snd_pcm_plugin *plugin_first; + struct snd_pcm_plugin *plugin_last; unsigned int prev_hw_ptr_interrupt; -} snd_pcm_oss_runtime_t; +}; -typedef struct _snd_pcm_oss_file { - snd_pcm_substream_t *streams[2]; -} snd_pcm_oss_file_t; +struct snd_pcm_oss_file { + struct snd_pcm_substream *streams[2]; +}; -typedef struct _snd_pcm_oss_substream { +struct snd_pcm_oss_substream { unsigned oss: 1; /* oss mode */ - snd_pcm_oss_setup_t *setup; /* active setup */ - snd_pcm_oss_file_t *file; -} snd_pcm_oss_substream_t; + struct snd_pcm_oss_setup *setup; /* active setup */ + struct snd_pcm_oss_file *file; +}; -typedef struct _snd_pcm_oss_stream { - snd_pcm_oss_setup_t *setup_list; /* setup list */ +struct snd_pcm_oss_stream { + struct snd_pcm_oss_setup *setup_list; /* setup list */ struct semaphore setup_mutex; - snd_info_entry_t *proc_entry; -} snd_pcm_oss_stream_t; + struct snd_info_entry *proc_entry; +}; -typedef struct _snd_pcm_oss { +struct snd_pcm_oss { int reg; unsigned int reg_mask; -} snd_pcm_oss_t; +}; #endif /* __SOUND_PCM_OSS_H */ diff --git a/sound/core/oss/copy.c b/sound/core/oss/copy.c index edecbe7417bd..d6a04c2d5a75 100644 --- a/sound/core/oss/copy.c +++ b/sound/core/oss/copy.c @@ -25,9 +25,9 @@ #include #include "pcm_plugin.h" -static snd_pcm_sframes_t copy_transfer(snd_pcm_plugin_t *plugin, - const snd_pcm_plugin_channel_t *src_channels, - snd_pcm_plugin_channel_t *dst_channels, +static snd_pcm_sframes_t copy_transfer(struct snd_pcm_plugin *plugin, + const struct snd_pcm_plugin_channel *src_channels, + struct snd_pcm_plugin_channel *dst_channels, snd_pcm_uframes_t frames) { unsigned int channel; @@ -58,13 +58,13 @@ static snd_pcm_sframes_t copy_transfer(snd_pcm_plugin_t *plugin, return frames; } -int snd_pcm_plugin_build_copy(snd_pcm_plug_t *plug, - snd_pcm_plugin_format_t *src_format, - snd_pcm_plugin_format_t *dst_format, - snd_pcm_plugin_t **r_plugin) +int snd_pcm_plugin_build_copy(struct snd_pcm_substream *plug, + struct snd_pcm_plugin_format *src_format, + struct snd_pcm_plugin_format *dst_format, + struct snd_pcm_plugin **r_plugin) { int err; - snd_pcm_plugin_t *plugin; + struct snd_pcm_plugin *plugin; int width; snd_assert(r_plugin != NULL, return -ENXIO); diff --git a/sound/core/oss/io.c b/sound/core/oss/io.c index 63eca9aec961..322702e05f3e 100644 --- a/sound/core/oss/io.c +++ b/sound/core/oss/io.c @@ -35,9 +35,9 @@ * Basic io plugin */ -static snd_pcm_sframes_t io_playback_transfer(snd_pcm_plugin_t *plugin, - const snd_pcm_plugin_channel_t *src_channels, - snd_pcm_plugin_channel_t *dst_channels, +static snd_pcm_sframes_t io_playback_transfer(struct snd_pcm_plugin *plugin, + const struct snd_pcm_plugin_channel *src_channels, + struct snd_pcm_plugin_channel *dst_channels, snd_pcm_uframes_t frames) { snd_assert(plugin != NULL, return -ENXIO); @@ -58,9 +58,9 @@ static snd_pcm_sframes_t io_playback_transfer(snd_pcm_plugin_t *plugin, } } -static snd_pcm_sframes_t io_capture_transfer(snd_pcm_plugin_t *plugin, - const snd_pcm_plugin_channel_t *src_channels, - snd_pcm_plugin_channel_t *dst_channels, +static snd_pcm_sframes_t io_capture_transfer(struct snd_pcm_plugin *plugin, + const struct snd_pcm_plugin_channel *src_channels, + struct snd_pcm_plugin_channel *dst_channels, snd_pcm_uframes_t frames) { snd_assert(plugin != NULL, return -ENXIO); @@ -82,13 +82,13 @@ static snd_pcm_sframes_t io_capture_transfer(snd_pcm_plugin_t *plugin, return 0; } -static snd_pcm_sframes_t io_src_channels(snd_pcm_plugin_t *plugin, +static snd_pcm_sframes_t io_src_channels(struct snd_pcm_plugin *plugin, snd_pcm_uframes_t frames, - snd_pcm_plugin_channel_t **channels) + struct snd_pcm_plugin_channel **channels) { int err; unsigned int channel; - snd_pcm_plugin_channel_t *v; + struct snd_pcm_plugin_channel *v; err = snd_pcm_plugin_client_channels(plugin, frames, &v); if (err < 0) return err; @@ -100,13 +100,13 @@ static snd_pcm_sframes_t io_src_channels(snd_pcm_plugin_t *plugin, return frames; } -int snd_pcm_plugin_build_io(snd_pcm_plug_t *plug, - snd_pcm_hw_params_t *params, - snd_pcm_plugin_t **r_plugin) +int snd_pcm_plugin_build_io(struct snd_pcm_substream *plug, + struct snd_pcm_hw_params *params, + struct snd_pcm_plugin **r_plugin) { int err; - snd_pcm_plugin_format_t format; - snd_pcm_plugin_t *plugin; + struct snd_pcm_plugin_format format; + struct snd_pcm_plugin *plugin; snd_assert(r_plugin != NULL, return -ENXIO); *r_plugin = NULL; diff --git a/sound/core/oss/linear.c b/sound/core/oss/linear.c index 12ed27a57b27..8cbfa415ce40 100644 --- a/sound/core/oss/linear.c +++ b/sound/core/oss/linear.c @@ -30,19 +30,19 @@ * Basic linear conversion plugin */ -typedef struct linear_private_data { +struct linear_priv { int conv; -} linear_t; +}; -static void convert(snd_pcm_plugin_t *plugin, - const snd_pcm_plugin_channel_t *src_channels, - snd_pcm_plugin_channel_t *dst_channels, +static void convert(struct snd_pcm_plugin *plugin, + const struct snd_pcm_plugin_channel *src_channels, + struct snd_pcm_plugin_channel *dst_channels, snd_pcm_uframes_t frames) { #define CONV_LABELS #include "plugin_ops.h" #undef CONV_LABELS - linear_t *data = (linear_t *)plugin->extra_data; + struct linear_priv *data = (struct linear_priv *)plugin->extra_data; void *conv = conv_labels[data->conv]; int channel; int nchannels = plugin->src_format.channels; @@ -75,15 +75,15 @@ static void convert(snd_pcm_plugin_t *plugin, } } -static snd_pcm_sframes_t linear_transfer(snd_pcm_plugin_t *plugin, - const snd_pcm_plugin_channel_t *src_channels, - snd_pcm_plugin_channel_t *dst_channels, +static snd_pcm_sframes_t linear_transfer(struct snd_pcm_plugin *plugin, + const struct snd_pcm_plugin_channel *src_channels, + struct snd_pcm_plugin_channel *dst_channels, snd_pcm_uframes_t frames) { - linear_t *data; + struct linear_priv *data; snd_assert(plugin != NULL && src_channels != NULL && dst_channels != NULL, return -ENXIO); - data = (linear_t *)plugin->extra_data; + data = (struct linear_priv *)plugin->extra_data; if (frames == 0) return 0; #ifdef CONFIG_SND_DEBUG @@ -128,14 +128,14 @@ int conv_index(int src_format, int dst_format) return src_width * 32 + src_endian * 16 + sign * 8 + dst_width * 2 + dst_endian; } -int snd_pcm_plugin_build_linear(snd_pcm_plug_t *plug, - snd_pcm_plugin_format_t *src_format, - snd_pcm_plugin_format_t *dst_format, - snd_pcm_plugin_t **r_plugin) +int snd_pcm_plugin_build_linear(struct snd_pcm_substream *plug, + struct snd_pcm_plugin_format *src_format, + struct snd_pcm_plugin_format *dst_format, + struct snd_pcm_plugin **r_plugin) { int err; - struct linear_private_data *data; - snd_pcm_plugin_t *plugin; + struct linear_priv *data; + struct snd_pcm_plugin *plugin; snd_assert(r_plugin != NULL, return -ENXIO); *r_plugin = NULL; @@ -147,10 +147,10 @@ int snd_pcm_plugin_build_linear(snd_pcm_plug_t *plug, err = snd_pcm_plugin_build(plug, "linear format conversion", src_format, dst_format, - sizeof(linear_t), &plugin); + sizeof(struct linear_priv), &plugin); if (err < 0) return err; - data = (linear_t *)plugin->extra_data; + data = (struct linear_priv *)plugin->extra_data; data->conv = conv_index(src_format->format, dst_format->format); plugin->transfer = linear_transfer; *r_plugin = plugin; diff --git a/sound/core/oss/mulaw.c b/sound/core/oss/mulaw.c index 44ec4c66eb19..14f5578ec7a7 100644 --- a/sound/core/oss/mulaw.c +++ b/sound/core/oss/mulaw.c @@ -139,25 +139,25 @@ static int ulaw2linear(unsigned char u_val) * Basic Mu-Law plugin */ -typedef void (*mulaw_f)(snd_pcm_plugin_t *plugin, - const snd_pcm_plugin_channel_t *src_channels, - snd_pcm_plugin_channel_t *dst_channels, +typedef void (*mulaw_f)(struct snd_pcm_plugin *plugin, + const struct snd_pcm_plugin_channel *src_channels, + struct snd_pcm_plugin_channel *dst_channels, snd_pcm_uframes_t frames); -typedef struct mulaw_private_data { +struct mulaw_priv { mulaw_f func; int conv; -} mulaw_t; +}; -static void mulaw_decode(snd_pcm_plugin_t *plugin, - const snd_pcm_plugin_channel_t *src_channels, - snd_pcm_plugin_channel_t *dst_channels, +static void mulaw_decode(struct snd_pcm_plugin *plugin, + const struct snd_pcm_plugin_channel *src_channels, + struct snd_pcm_plugin_channel *dst_channels, snd_pcm_uframes_t frames) { #define PUT_S16_LABELS #include "plugin_ops.h" #undef PUT_S16_LABELS - mulaw_t *data = (mulaw_t *)plugin->extra_data; + struct mulaw_priv *data = (struct mulaw_priv *)plugin->extra_data; void *put = put_s16_labels[data->conv]; int channel; int nchannels = plugin->src_format.channels; @@ -191,15 +191,15 @@ static void mulaw_decode(snd_pcm_plugin_t *plugin, } } -static void mulaw_encode(snd_pcm_plugin_t *plugin, - const snd_pcm_plugin_channel_t *src_channels, - snd_pcm_plugin_channel_t *dst_channels, +static void mulaw_encode(struct snd_pcm_plugin *plugin, + const struct snd_pcm_plugin_channel *src_channels, + struct snd_pcm_plugin_channel *dst_channels, snd_pcm_uframes_t frames) { #define GET_S16_LABELS #include "plugin_ops.h" #undef GET_S16_LABELS - mulaw_t *data = (mulaw_t *)plugin->extra_data; + struct mulaw_priv *data = (struct mulaw_priv *)plugin->extra_data; void *get = get_s16_labels[data->conv]; int channel; int nchannels = plugin->src_format.channels; @@ -234,12 +234,12 @@ static void mulaw_encode(snd_pcm_plugin_t *plugin, } } -static snd_pcm_sframes_t mulaw_transfer(snd_pcm_plugin_t *plugin, - const snd_pcm_plugin_channel_t *src_channels, - snd_pcm_plugin_channel_t *dst_channels, +static snd_pcm_sframes_t mulaw_transfer(struct snd_pcm_plugin *plugin, + const struct snd_pcm_plugin_channel *src_channels, + struct snd_pcm_plugin_channel *dst_channels, snd_pcm_uframes_t frames) { - mulaw_t *data; + struct mulaw_priv *data; snd_assert(plugin != NULL && src_channels != NULL && dst_channels != NULL, return -ENXIO); if (frames == 0) @@ -257,20 +257,20 @@ static snd_pcm_sframes_t mulaw_transfer(snd_pcm_plugin_t *plugin, } } #endif - data = (mulaw_t *)plugin->extra_data; + data = (struct mulaw_priv *)plugin->extra_data; data->func(plugin, src_channels, dst_channels, frames); return frames; } -int snd_pcm_plugin_build_mulaw(snd_pcm_plug_t *plug, - snd_pcm_plugin_format_t *src_format, - snd_pcm_plugin_format_t *dst_format, - snd_pcm_plugin_t **r_plugin) +int snd_pcm_plugin_build_mulaw(struct snd_pcm_substream *plug, + struct snd_pcm_plugin_format *src_format, + struct snd_pcm_plugin_format *dst_format, + struct snd_pcm_plugin **r_plugin) { int err; - mulaw_t *data; - snd_pcm_plugin_t *plugin; - snd_pcm_plugin_format_t *format; + struct mulaw_priv *data; + struct snd_pcm_plugin *plugin; + struct snd_pcm_plugin_format *format; mulaw_f func; snd_assert(r_plugin != NULL, return -ENXIO); @@ -295,10 +295,10 @@ int snd_pcm_plugin_build_mulaw(snd_pcm_plug_t *plug, err = snd_pcm_plugin_build(plug, "Mu-Law<->linear conversion", src_format, dst_format, - sizeof(mulaw_t), &plugin); + sizeof(struct mulaw_priv), &plugin); if (err < 0) return err; - data = (mulaw_t*)plugin->extra_data; + data = (struct mulaw_priv *)plugin->extra_data; data->func = func; data->conv = getput_index(format->format); snd_assert(data->conv >= 0 && data->conv < 4*2*2, return -EINVAL); diff --git a/sound/core/oss/pcm_oss.c b/sound/core/oss/pcm_oss.c index bcc970759134..ffc13b9194b7 100644 --- a/sound/core/oss/pcm_oss.c +++ b/sound/core/oss/pcm_oss.c @@ -61,10 +61,10 @@ MODULE_PARM_DESC(nonblock_open, "Don't block opening busy PCM devices."); MODULE_ALIAS_SNDRV_MINOR(SNDRV_MINOR_OSS_PCM); MODULE_ALIAS_SNDRV_MINOR(SNDRV_MINOR_OSS_PCM1); -extern int snd_mixer_oss_ioctl_card(snd_card_t *card, unsigned int cmd, unsigned long arg); -static int snd_pcm_oss_get_rate(snd_pcm_oss_file_t *pcm_oss_file); -static int snd_pcm_oss_get_channels(snd_pcm_oss_file_t *pcm_oss_file); -static int snd_pcm_oss_get_format(snd_pcm_oss_file_t *pcm_oss_file); +extern int snd_mixer_oss_ioctl_card(struct snd_card *card, unsigned int cmd, unsigned long arg); +static int snd_pcm_oss_get_rate(struct snd_pcm_oss_file *pcm_oss_file); +static int snd_pcm_oss_get_channels(struct snd_pcm_oss_file *pcm_oss_file); +static int snd_pcm_oss_get_format(struct snd_pcm_oss_file *pcm_oss_file); static inline mm_segment_t snd_enter_user(void) { @@ -78,10 +78,10 @@ static inline void snd_leave_user(mm_segment_t fs) set_fs(fs); } -static int snd_pcm_oss_plugin_clear(snd_pcm_substream_t *substream) +static int snd_pcm_oss_plugin_clear(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime = substream->runtime; - snd_pcm_plugin_t *plugin, *next; + struct snd_pcm_runtime *runtime = substream->runtime; + struct snd_pcm_plugin *plugin, *next; plugin = runtime->oss.plugin_first; while (plugin) { @@ -93,9 +93,9 @@ static int snd_pcm_oss_plugin_clear(snd_pcm_substream_t *substream) return 0; } -static int snd_pcm_plugin_insert(snd_pcm_plugin_t *plugin) +static int snd_pcm_plugin_insert(struct snd_pcm_plugin *plugin) { - snd_pcm_runtime_t *runtime = plugin->plug->runtime; + struct snd_pcm_runtime *runtime = plugin->plug->runtime; plugin->next = runtime->oss.plugin_first; plugin->prev = NULL; if (runtime->oss.plugin_first) { @@ -108,9 +108,9 @@ static int snd_pcm_plugin_insert(snd_pcm_plugin_t *plugin) return 0; } -int snd_pcm_plugin_append(snd_pcm_plugin_t *plugin) +int snd_pcm_plugin_append(struct snd_pcm_plugin *plugin) { - snd_pcm_runtime_t *runtime = plugin->plug->runtime; + struct snd_pcm_runtime *runtime = plugin->plug->runtime; plugin->next = NULL; plugin->prev = runtime->oss.plugin_last; if (runtime->oss.plugin_last) { @@ -123,9 +123,9 @@ int snd_pcm_plugin_append(snd_pcm_plugin_t *plugin) return 0; } -static long snd_pcm_oss_bytes(snd_pcm_substream_t *substream, long frames) +static long snd_pcm_oss_bytes(struct snd_pcm_substream *substream, long frames) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; long buffer_size = snd_pcm_lib_buffer_bytes(substream); long bytes = frames_to_bytes(runtime, frames); if (buffer_size == runtime->oss.buffer_bytes) @@ -142,9 +142,9 @@ static long snd_pcm_oss_bytes(snd_pcm_substream_t *substream, long frames) #endif } -static long snd_pcm_alsa_frames(snd_pcm_substream_t *substream, long bytes) +static long snd_pcm_alsa_frames(struct snd_pcm_substream *substream, long bytes) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; long buffer_size = snd_pcm_lib_buffer_bytes(substream); if (buffer_size == runtime->oss.buffer_bytes) return bytes_to_frames(runtime, bytes); @@ -185,14 +185,14 @@ static int snd_pcm_oss_format_to(int format) } } -static int snd_pcm_oss_period_size(snd_pcm_substream_t *substream, - snd_pcm_hw_params_t *oss_params, - snd_pcm_hw_params_t *slave_params) +static int snd_pcm_oss_period_size(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params *oss_params, + struct snd_pcm_hw_params *slave_params) { size_t s; size_t oss_buffer_size, oss_period_size, oss_periods; size_t min_period_size, max_period_size; - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; size_t oss_frame_size; oss_frame_size = snd_pcm_format_physical_width(params_format(oss_params)) * @@ -277,11 +277,11 @@ static int snd_pcm_oss_period_size(snd_pcm_substream_t *substream, return 0; } -static int choose_rate(snd_pcm_substream_t *substream, - snd_pcm_hw_params_t *params, unsigned int best_rate) +static int choose_rate(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params *params, unsigned int best_rate) { - snd_interval_t *it; - snd_pcm_hw_params_t *save; + struct snd_interval *it; + struct snd_pcm_hw_params *save; unsigned int rate, prev; save = kmalloc(sizeof(*save), GFP_KERNEL); @@ -317,18 +317,18 @@ static int choose_rate(snd_pcm_substream_t *substream, return snd_pcm_hw_param_near(substream, params, SNDRV_PCM_HW_PARAM_RATE, best_rate, NULL); } -static int snd_pcm_oss_change_params(snd_pcm_substream_t *substream) +static int snd_pcm_oss_change_params(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime = substream->runtime; - snd_pcm_hw_params_t *params, *sparams; - snd_pcm_sw_params_t *sw_params; + struct snd_pcm_runtime *runtime = substream->runtime; + struct snd_pcm_hw_params *params, *sparams; + struct snd_pcm_sw_params *sw_params; ssize_t oss_buffer_size, oss_period_size; size_t oss_frame_size; int err; int direct; int format, sformat, n; - snd_mask_t sformat_mask; - snd_mask_t mask; + struct snd_mask sformat_mask; + struct snd_mask mask; sw_params = kmalloc(sizeof(*sw_params), GFP_KERNEL); params = kmalloc(sizeof(*params), GFP_KERNEL); @@ -342,7 +342,7 @@ static int snd_pcm_oss_change_params(snd_pcm_substream_t *substream) if (atomic_read(&runtime->mmap_count)) { direct = 1; } else { - snd_pcm_oss_setup_t *setup = substream->oss.setup; + struct snd_pcm_oss_setup *setup = substream->oss.setup; direct = (setup != NULL && setup->direct); } @@ -424,7 +424,7 @@ static int snd_pcm_oss_change_params(snd_pcm_substream_t *substream) goto failure; } if (runtime->oss.plugin_first) { - snd_pcm_plugin_t *plugin; + struct snd_pcm_plugin *plugin; if ((err = snd_pcm_plugin_build_io(substream, sparams, &plugin)) < 0) { snd_printd("snd_pcm_plugin_build_io failed: %i\n", err); snd_pcm_oss_plugin_clear(substream); @@ -540,10 +540,10 @@ failure: return err; } -static int snd_pcm_oss_get_active_substream(snd_pcm_oss_file_t *pcm_oss_file, snd_pcm_substream_t **r_substream) +static int snd_pcm_oss_get_active_substream(struct snd_pcm_oss_file *pcm_oss_file, struct snd_pcm_substream **r_substream) { int idx, err; - snd_pcm_substream_t *asubstream = NULL, *substream; + struct snd_pcm_substream *asubstream = NULL, *substream; for (idx = 0; idx < 2; idx++) { substream = pcm_oss_file->streams[idx]; @@ -563,10 +563,10 @@ static int snd_pcm_oss_get_active_substream(snd_pcm_oss_file_t *pcm_oss_file, sn return 0; } -static int snd_pcm_oss_prepare(snd_pcm_substream_t *substream) +static int snd_pcm_oss_prepare(struct snd_pcm_substream *substream) { int err; - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; err = snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_PREPARE, NULL); if (err < 0) { @@ -581,9 +581,9 @@ static int snd_pcm_oss_prepare(snd_pcm_substream_t *substream) return 0; } -static int snd_pcm_oss_make_ready(snd_pcm_substream_t *substream) +static int snd_pcm_oss_make_ready(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; int err; if (substream == NULL) @@ -602,9 +602,9 @@ static int snd_pcm_oss_make_ready(snd_pcm_substream_t *substream) return 0; } -static int snd_pcm_oss_capture_position_fixup(snd_pcm_substream_t *substream, snd_pcm_sframes_t *delay) +static int snd_pcm_oss_capture_position_fixup(struct snd_pcm_substream *substream, snd_pcm_sframes_t *delay) { - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; snd_pcm_uframes_t frames; int err = 0; @@ -627,9 +627,9 @@ static int snd_pcm_oss_capture_position_fixup(snd_pcm_substream_t *substream, sn return err; } -snd_pcm_sframes_t snd_pcm_oss_write3(snd_pcm_substream_t *substream, const char *ptr, snd_pcm_uframes_t frames, int in_kernel) +snd_pcm_sframes_t snd_pcm_oss_write3(struct snd_pcm_substream *substream, const char *ptr, snd_pcm_uframes_t frames, int in_kernel) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; int ret; while (1) { if (runtime->status->state == SNDRV_PCM_STATE_XRUN || @@ -662,9 +662,9 @@ snd_pcm_sframes_t snd_pcm_oss_write3(snd_pcm_substream_t *substream, const char return ret; } -snd_pcm_sframes_t snd_pcm_oss_read3(snd_pcm_substream_t *substream, char *ptr, snd_pcm_uframes_t frames, int in_kernel) +snd_pcm_sframes_t snd_pcm_oss_read3(struct snd_pcm_substream *substream, char *ptr, snd_pcm_uframes_t frames, int in_kernel) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_sframes_t delay; int ret; while (1) { @@ -709,9 +709,9 @@ snd_pcm_sframes_t snd_pcm_oss_read3(snd_pcm_substream_t *substream, char *ptr, s return ret; } -snd_pcm_sframes_t snd_pcm_oss_writev3(snd_pcm_substream_t *substream, void **bufs, snd_pcm_uframes_t frames, int in_kernel) +snd_pcm_sframes_t snd_pcm_oss_writev3(struct snd_pcm_substream *substream, void **bufs, snd_pcm_uframes_t frames, int in_kernel) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; int ret; while (1) { if (runtime->status->state == SNDRV_PCM_STATE_XRUN || @@ -745,9 +745,9 @@ snd_pcm_sframes_t snd_pcm_oss_writev3(snd_pcm_substream_t *substream, void **buf return ret; } -snd_pcm_sframes_t snd_pcm_oss_readv3(snd_pcm_substream_t *substream, void **bufs, snd_pcm_uframes_t frames, int in_kernel) +snd_pcm_sframes_t snd_pcm_oss_readv3(struct snd_pcm_substream *substream, void **bufs, snd_pcm_uframes_t frames, int in_kernel) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; int ret; while (1) { if (runtime->status->state == SNDRV_PCM_STATE_XRUN || @@ -780,12 +780,12 @@ snd_pcm_sframes_t snd_pcm_oss_readv3(snd_pcm_substream_t *substream, void **bufs return ret; } -static ssize_t snd_pcm_oss_write2(snd_pcm_substream_t *substream, const char *buf, size_t bytes, int in_kernel) +static ssize_t snd_pcm_oss_write2(struct snd_pcm_substream *substream, const char *buf, size_t bytes, int in_kernel) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_sframes_t frames, frames1; if (runtime->oss.plugin_first) { - snd_pcm_plugin_channel_t *channels; + struct snd_pcm_plugin_channel *channels; size_t oss_frame_bytes = (runtime->oss.plugin_first->src_width * runtime->oss.plugin_first->src_format.channels) / 8; if (!in_kernel) { if (copy_from_user(runtime->oss.buffer, (const char __user *)buf, bytes)) @@ -810,11 +810,11 @@ static ssize_t snd_pcm_oss_write2(snd_pcm_substream_t *substream, const char *bu return bytes; } -static ssize_t snd_pcm_oss_write1(snd_pcm_substream_t *substream, const char __user *buf, size_t bytes) +static ssize_t snd_pcm_oss_write1(struct snd_pcm_substream *substream, const char __user *buf, size_t bytes) { size_t xfer = 0; ssize_t tmp; - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; if (atomic_read(&runtime->mmap_count)) return -ENXIO; @@ -867,13 +867,13 @@ static ssize_t snd_pcm_oss_write1(snd_pcm_substream_t *substream, const char __u return xfer; } -static ssize_t snd_pcm_oss_read2(snd_pcm_substream_t *substream, char *buf, size_t bytes, int in_kernel) +static ssize_t snd_pcm_oss_read2(struct snd_pcm_substream *substream, char *buf, size_t bytes, int in_kernel) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_sframes_t frames, frames1; char __user *final_dst = (char __user *)buf; if (runtime->oss.plugin_first) { - snd_pcm_plugin_channel_t *channels; + struct snd_pcm_plugin_channel *channels; size_t oss_frame_bytes = (runtime->oss.plugin_last->dst_width * runtime->oss.plugin_last->dst_format.channels) / 8; if (!in_kernel) buf = runtime->oss.buffer; @@ -897,11 +897,11 @@ static ssize_t snd_pcm_oss_read2(snd_pcm_substream_t *substream, char *buf, size return bytes; } -static ssize_t snd_pcm_oss_read1(snd_pcm_substream_t *substream, char __user *buf, size_t bytes) +static ssize_t snd_pcm_oss_read1(struct snd_pcm_substream *substream, char __user *buf, size_t bytes) { size_t xfer = 0; ssize_t tmp; - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; if (atomic_read(&runtime->mmap_count)) return -ENXIO; @@ -941,9 +941,9 @@ static ssize_t snd_pcm_oss_read1(snd_pcm_substream_t *substream, char __user *bu return xfer; } -static int snd_pcm_oss_reset(snd_pcm_oss_file_t *pcm_oss_file) +static int snd_pcm_oss_reset(struct snd_pcm_oss_file *pcm_oss_file) { - snd_pcm_substream_t *substream; + struct snd_pcm_substream *substream; substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_PLAYBACK]; if (substream != NULL) { @@ -958,9 +958,9 @@ static int snd_pcm_oss_reset(snd_pcm_oss_file_t *pcm_oss_file) return 0; } -static int snd_pcm_oss_post(snd_pcm_oss_file_t *pcm_oss_file) +static int snd_pcm_oss_post(struct snd_pcm_oss_file *pcm_oss_file) { - snd_pcm_substream_t *substream; + struct snd_pcm_substream *substream; int err; substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_PLAYBACK]; @@ -974,9 +974,9 @@ static int snd_pcm_oss_post(snd_pcm_oss_file_t *pcm_oss_file) return 0; } -static int snd_pcm_oss_sync1(snd_pcm_substream_t *substream, size_t size) +static int snd_pcm_oss_sync1(struct snd_pcm_substream *substream, size_t size) { - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; ssize_t result = 0; long res; wait_queue_t wait; @@ -1020,12 +1020,12 @@ static int snd_pcm_oss_sync1(snd_pcm_substream_t *substream, size_t size) return result; } -static int snd_pcm_oss_sync(snd_pcm_oss_file_t *pcm_oss_file) +static int snd_pcm_oss_sync(struct snd_pcm_oss_file *pcm_oss_file) { int err = 0; unsigned int saved_f_flags; - snd_pcm_substream_t *substream; - snd_pcm_runtime_t *runtime; + struct snd_pcm_substream *substream; + struct snd_pcm_runtime *runtime; snd_pcm_format_t format; unsigned long width; size_t size; @@ -1117,13 +1117,13 @@ static int snd_pcm_oss_sync(snd_pcm_oss_file_t *pcm_oss_file) return 0; } -static int snd_pcm_oss_set_rate(snd_pcm_oss_file_t *pcm_oss_file, int rate) +static int snd_pcm_oss_set_rate(struct snd_pcm_oss_file *pcm_oss_file, int rate) { int idx; for (idx = 1; idx >= 0; --idx) { - snd_pcm_substream_t *substream = pcm_oss_file->streams[idx]; - snd_pcm_runtime_t *runtime; + struct snd_pcm_substream *substream = pcm_oss_file->streams[idx]; + struct snd_pcm_runtime *runtime; if (substream == NULL) continue; runtime = substream->runtime; @@ -1139,9 +1139,9 @@ static int snd_pcm_oss_set_rate(snd_pcm_oss_file_t *pcm_oss_file, int rate) return snd_pcm_oss_get_rate(pcm_oss_file); } -static int snd_pcm_oss_get_rate(snd_pcm_oss_file_t *pcm_oss_file) +static int snd_pcm_oss_get_rate(struct snd_pcm_oss_file *pcm_oss_file) { - snd_pcm_substream_t *substream; + struct snd_pcm_substream *substream; int err; if ((err = snd_pcm_oss_get_active_substream(pcm_oss_file, &substream)) < 0) @@ -1149,7 +1149,7 @@ static int snd_pcm_oss_get_rate(snd_pcm_oss_file_t *pcm_oss_file) return substream->runtime->oss.rate; } -static int snd_pcm_oss_set_channels(snd_pcm_oss_file_t *pcm_oss_file, unsigned int channels) +static int snd_pcm_oss_set_channels(struct snd_pcm_oss_file *pcm_oss_file, unsigned int channels) { int idx; if (channels < 1) @@ -1157,8 +1157,8 @@ static int snd_pcm_oss_set_channels(snd_pcm_oss_file_t *pcm_oss_file, unsigned i if (channels > 128) return -EINVAL; for (idx = 1; idx >= 0; --idx) { - snd_pcm_substream_t *substream = pcm_oss_file->streams[idx]; - snd_pcm_runtime_t *runtime; + struct snd_pcm_substream *substream = pcm_oss_file->streams[idx]; + struct snd_pcm_runtime *runtime; if (substream == NULL) continue; runtime = substream->runtime; @@ -1170,9 +1170,9 @@ static int snd_pcm_oss_set_channels(snd_pcm_oss_file_t *pcm_oss_file, unsigned i return snd_pcm_oss_get_channels(pcm_oss_file); } -static int snd_pcm_oss_get_channels(snd_pcm_oss_file_t *pcm_oss_file) +static int snd_pcm_oss_get_channels(struct snd_pcm_oss_file *pcm_oss_file) { - snd_pcm_substream_t *substream; + struct snd_pcm_substream *substream; int err; if ((err = snd_pcm_oss_get_active_substream(pcm_oss_file, &substream)) < 0) @@ -1180,9 +1180,9 @@ static int snd_pcm_oss_get_channels(snd_pcm_oss_file_t *pcm_oss_file) return substream->runtime->oss.channels; } -static int snd_pcm_oss_get_block_size(snd_pcm_oss_file_t *pcm_oss_file) +static int snd_pcm_oss_get_block_size(struct snd_pcm_oss_file *pcm_oss_file) { - snd_pcm_substream_t *substream; + struct snd_pcm_substream *substream; int err; if ((err = snd_pcm_oss_get_active_substream(pcm_oss_file, &substream)) < 0) @@ -1190,14 +1190,14 @@ static int snd_pcm_oss_get_block_size(snd_pcm_oss_file_t *pcm_oss_file) return substream->runtime->oss.period_bytes; } -static int snd_pcm_oss_get_formats(snd_pcm_oss_file_t *pcm_oss_file) +static int snd_pcm_oss_get_formats(struct snd_pcm_oss_file *pcm_oss_file) { - snd_pcm_substream_t *substream; + struct snd_pcm_substream *substream; int err; int direct; - snd_pcm_hw_params_t *params; + struct snd_pcm_hw_params *params; unsigned int formats = 0; - snd_mask_t format_mask; + struct snd_mask format_mask; int fmt; if ((err = snd_pcm_oss_get_active_substream(pcm_oss_file, &substream)) < 0) @@ -1205,7 +1205,7 @@ static int snd_pcm_oss_get_formats(snd_pcm_oss_file_t *pcm_oss_file) if (atomic_read(&substream->runtime->mmap_count)) { direct = 1; } else { - snd_pcm_oss_setup_t *setup = substream->oss.setup; + struct snd_pcm_oss_setup *setup = substream->oss.setup; direct = (setup != NULL && setup->direct); } if (!direct) @@ -1231,7 +1231,7 @@ static int snd_pcm_oss_get_formats(snd_pcm_oss_file_t *pcm_oss_file) return formats; } -static int snd_pcm_oss_set_format(snd_pcm_oss_file_t *pcm_oss_file, int format) +static int snd_pcm_oss_set_format(struct snd_pcm_oss_file *pcm_oss_file, int format) { int formats, idx; @@ -1240,8 +1240,8 @@ static int snd_pcm_oss_set_format(snd_pcm_oss_file_t *pcm_oss_file, int format) if (!(formats & format)) format = AFMT_U8; for (idx = 1; idx >= 0; --idx) { - snd_pcm_substream_t *substream = pcm_oss_file->streams[idx]; - snd_pcm_runtime_t *runtime; + struct snd_pcm_substream *substream = pcm_oss_file->streams[idx]; + struct snd_pcm_runtime *runtime; if (substream == NULL) continue; runtime = substream->runtime; @@ -1254,9 +1254,9 @@ static int snd_pcm_oss_set_format(snd_pcm_oss_file_t *pcm_oss_file, int format) return snd_pcm_oss_get_format(pcm_oss_file); } -static int snd_pcm_oss_get_format(snd_pcm_oss_file_t *pcm_oss_file) +static int snd_pcm_oss_get_format(struct snd_pcm_oss_file *pcm_oss_file) { - snd_pcm_substream_t *substream; + struct snd_pcm_substream *substream; int err; if ((err = snd_pcm_oss_get_active_substream(pcm_oss_file, &substream)) < 0) @@ -1264,9 +1264,9 @@ static int snd_pcm_oss_get_format(snd_pcm_oss_file_t *pcm_oss_file) return substream->runtime->oss.format; } -static int snd_pcm_oss_set_subdivide1(snd_pcm_substream_t *substream, int subdivide) +static int snd_pcm_oss_set_subdivide1(struct snd_pcm_substream *substream, int subdivide) { - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; if (substream == NULL) return 0; @@ -1287,12 +1287,12 @@ static int snd_pcm_oss_set_subdivide1(snd_pcm_substream_t *substream, int subdiv return subdivide; } -static int snd_pcm_oss_set_subdivide(snd_pcm_oss_file_t *pcm_oss_file, int subdivide) +static int snd_pcm_oss_set_subdivide(struct snd_pcm_oss_file *pcm_oss_file, int subdivide) { int err = -EINVAL, idx; for (idx = 1; idx >= 0; --idx) { - snd_pcm_substream_t *substream = pcm_oss_file->streams[idx]; + struct snd_pcm_substream *substream = pcm_oss_file->streams[idx]; if (substream == NULL) continue; if ((err = snd_pcm_oss_set_subdivide1(substream, subdivide)) < 0) @@ -1301,9 +1301,9 @@ static int snd_pcm_oss_set_subdivide(snd_pcm_oss_file_t *pcm_oss_file, int subdi return err; } -static int snd_pcm_oss_set_fragment1(snd_pcm_substream_t *substream, unsigned int val) +static int snd_pcm_oss_set_fragment1(struct snd_pcm_substream *substream, unsigned int val) { - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; if (substream == NULL) return 0; @@ -1320,12 +1320,12 @@ static int snd_pcm_oss_set_fragment1(snd_pcm_substream_t *substream, unsigned in return 0; } -static int snd_pcm_oss_set_fragment(snd_pcm_oss_file_t *pcm_oss_file, unsigned int val) +static int snd_pcm_oss_set_fragment(struct snd_pcm_oss_file *pcm_oss_file, unsigned int val) { int err = -EINVAL, idx; for (idx = 1; idx >= 0; --idx) { - snd_pcm_substream_t *substream = pcm_oss_file->streams[idx]; + struct snd_pcm_substream *substream = pcm_oss_file->streams[idx]; if (substream == NULL) continue; if ((err = snd_pcm_oss_set_fragment1(substream, val)) < 0) @@ -1340,7 +1340,7 @@ static int snd_pcm_oss_nonblock(struct file * file) return 0; } -static int snd_pcm_oss_get_caps1(snd_pcm_substream_t *substream, int res) +static int snd_pcm_oss_get_caps1(struct snd_pcm_substream *substream, int res) { if (substream == NULL) { @@ -1356,7 +1356,7 @@ static int snd_pcm_oss_get_caps1(snd_pcm_substream_t *substream, int res) /* all ALSA drivers can return actual pointer in ring buffer */ #if defined(DSP_CAP_REALTIME) && 0 { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; if (runtime->info & (SNDRV_PCM_INFO_BLOCK_TRANSFER|SNDRV_PCM_INFO_BATCH)) res &= ~DSP_CAP_REALTIME; } @@ -1364,32 +1364,32 @@ static int snd_pcm_oss_get_caps1(snd_pcm_substream_t *substream, int res) return res; } -static int snd_pcm_oss_get_caps(snd_pcm_oss_file_t *pcm_oss_file) +static int snd_pcm_oss_get_caps(struct snd_pcm_oss_file *pcm_oss_file) { int result, idx; result = DSP_CAP_TRIGGER | DSP_CAP_MMAP | DSP_CAP_DUPLEX | DSP_CAP_REALTIME; for (idx = 0; idx < 2; idx++) { - snd_pcm_substream_t *substream = pcm_oss_file->streams[idx]; + struct snd_pcm_substream *substream = pcm_oss_file->streams[idx]; result = snd_pcm_oss_get_caps1(substream, result); } result |= 0x0001; /* revision - same as SB AWE 64 */ return result; } -static void snd_pcm_oss_simulate_fill(snd_pcm_substream_t *substream, snd_pcm_uframes_t hw_ptr) +static void snd_pcm_oss_simulate_fill(struct snd_pcm_substream *substream, snd_pcm_uframes_t hw_ptr) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_uframes_t appl_ptr; appl_ptr = hw_ptr + runtime->buffer_size; appl_ptr %= runtime->boundary; runtime->control->appl_ptr = appl_ptr; } -static int snd_pcm_oss_set_trigger(snd_pcm_oss_file_t *pcm_oss_file, int trigger) +static int snd_pcm_oss_set_trigger(struct snd_pcm_oss_file *pcm_oss_file, int trigger) { - snd_pcm_runtime_t *runtime; - snd_pcm_substream_t *psubstream = NULL, *csubstream = NULL; + struct snd_pcm_runtime *runtime; + struct snd_pcm_substream *psubstream = NULL, *csubstream = NULL; int err, cmd; #ifdef OSS_DEBUG @@ -1454,9 +1454,9 @@ static int snd_pcm_oss_set_trigger(snd_pcm_oss_file_t *pcm_oss_file, int trigger return 0; } -static int snd_pcm_oss_get_trigger(snd_pcm_oss_file_t *pcm_oss_file) +static int snd_pcm_oss_get_trigger(struct snd_pcm_oss_file *pcm_oss_file) { - snd_pcm_substream_t *psubstream = NULL, *csubstream = NULL; + struct snd_pcm_substream *psubstream = NULL, *csubstream = NULL; int result = 0; psubstream = pcm_oss_file->streams[SNDRV_PCM_STREAM_PLAYBACK]; @@ -1468,10 +1468,10 @@ static int snd_pcm_oss_get_trigger(snd_pcm_oss_file_t *pcm_oss_file) return result; } -static int snd_pcm_oss_get_odelay(snd_pcm_oss_file_t *pcm_oss_file) +static int snd_pcm_oss_get_odelay(struct snd_pcm_oss_file *pcm_oss_file) { - snd_pcm_substream_t *substream; - snd_pcm_runtime_t *runtime; + struct snd_pcm_substream *substream; + struct snd_pcm_runtime *runtime; snd_pcm_sframes_t delay; int err; @@ -1491,10 +1491,10 @@ static int snd_pcm_oss_get_odelay(snd_pcm_oss_file_t *pcm_oss_file) return snd_pcm_oss_bytes(substream, delay); } -static int snd_pcm_oss_get_ptr(snd_pcm_oss_file_t *pcm_oss_file, int stream, struct count_info __user * _info) +static int snd_pcm_oss_get_ptr(struct snd_pcm_oss_file *pcm_oss_file, int stream, struct count_info __user * _info) { - snd_pcm_substream_t *substream; - snd_pcm_runtime_t *runtime; + struct snd_pcm_substream *substream; + struct snd_pcm_runtime *runtime; snd_pcm_sframes_t delay; int fixup; struct count_info info; @@ -1543,7 +1543,7 @@ static int snd_pcm_oss_get_ptr(snd_pcm_oss_file_t *pcm_oss_file, int stream, str } else { delay = snd_pcm_oss_bytes(substream, delay); if (stream == SNDRV_PCM_STREAM_PLAYBACK) { - snd_pcm_oss_setup_t *setup = substream->oss.setup; + struct snd_pcm_oss_setup *setup = substream->oss.setup; if (setup && setup->buggyptr) info.blocks = (runtime->oss.buffer_bytes - delay - fixup) / runtime->oss.period_bytes; else @@ -1560,10 +1560,10 @@ static int snd_pcm_oss_get_ptr(snd_pcm_oss_file_t *pcm_oss_file, int stream, str return 0; } -static int snd_pcm_oss_get_space(snd_pcm_oss_file_t *pcm_oss_file, int stream, struct audio_buf_info __user *_info) +static int snd_pcm_oss_get_space(struct snd_pcm_oss_file *pcm_oss_file, int stream, struct audio_buf_info __user *_info) { - snd_pcm_substream_t *substream; - snd_pcm_runtime_t *runtime; + struct snd_pcm_substream *substream; + struct snd_pcm_runtime *runtime; snd_pcm_sframes_t avail; int fixup; struct audio_buf_info info; @@ -1619,17 +1619,17 @@ static int snd_pcm_oss_get_space(snd_pcm_oss_file_t *pcm_oss_file, int stream, s return 0; } -static int snd_pcm_oss_get_mapbuf(snd_pcm_oss_file_t *pcm_oss_file, int stream, struct buffmem_desc __user * _info) +static int snd_pcm_oss_get_mapbuf(struct snd_pcm_oss_file *pcm_oss_file, int stream, struct buffmem_desc __user * _info) { // it won't be probably implemented // snd_printd("TODO: snd_pcm_oss_get_mapbuf\n"); return -EINVAL; } -static snd_pcm_oss_setup_t *snd_pcm_oss_look_for_setup(snd_pcm_t *pcm, int stream, const char *task_name) +static struct snd_pcm_oss_setup *snd_pcm_oss_look_for_setup(struct snd_pcm *pcm, int stream, const char *task_name) { const char *ptr, *ptrl; - snd_pcm_oss_setup_t *setup; + struct snd_pcm_oss_setup *setup; down(&pcm->streams[stream].oss.setup_mutex); for (setup = pcm->streams[stream].oss.setup_list; setup; setup = setup->next) { @@ -1659,11 +1659,11 @@ static snd_pcm_oss_setup_t *snd_pcm_oss_look_for_setup(snd_pcm_t *pcm, int strea return NULL; } -static void snd_pcm_oss_init_substream(snd_pcm_substream_t *substream, - snd_pcm_oss_setup_t *setup, +static void snd_pcm_oss_init_substream(struct snd_pcm_substream *substream, + struct snd_pcm_oss_setup *setup, int minor) { - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; substream->oss.oss = 1; substream->oss.setup = setup; @@ -1687,9 +1687,9 @@ static void snd_pcm_oss_init_substream(snd_pcm_substream_t *substream, runtime->oss.subdivision = 0; } -static void snd_pcm_oss_release_substream(snd_pcm_substream_t *substream) +static void snd_pcm_oss_release_substream(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime; + struct snd_pcm_runtime *runtime; runtime = substream->runtime; vfree(runtime->oss.buffer); snd_pcm_oss_plugin_clear(substream); @@ -1697,13 +1697,13 @@ static void snd_pcm_oss_release_substream(snd_pcm_substream_t *substream) substream->oss.oss = 0; } -static int snd_pcm_oss_release_file(snd_pcm_oss_file_t *pcm_oss_file) +static int snd_pcm_oss_release_file(struct snd_pcm_oss_file *pcm_oss_file) { int cidx; snd_assert(pcm_oss_file != NULL, return -ENXIO); for (cidx = 0; cidx < 2; ++cidx) { - snd_pcm_substream_t *substream = pcm_oss_file->streams[cidx]; - snd_pcm_runtime_t *runtime; + struct snd_pcm_substream *substream = pcm_oss_file->streams[cidx]; + struct snd_pcm_runtime *runtime; if (substream == NULL) continue; runtime = substream->runtime; @@ -1726,15 +1726,15 @@ static int snd_pcm_oss_release_file(snd_pcm_oss_file_t *pcm_oss_file) } static int snd_pcm_oss_open_file(struct file *file, - snd_pcm_t *pcm, - snd_pcm_oss_file_t **rpcm_oss_file, + struct snd_pcm *pcm, + struct snd_pcm_oss_file **rpcm_oss_file, int minor, - snd_pcm_oss_setup_t *psetup, - snd_pcm_oss_setup_t *csetup) + struct snd_pcm_oss_setup *psetup, + struct snd_pcm_oss_setup *csetup) { int err = 0; - snd_pcm_oss_file_t *pcm_oss_file; - snd_pcm_substream_t *psubstream = NULL, *csubstream = NULL; + struct snd_pcm_oss_file *pcm_oss_file; + struct snd_pcm_substream *psubstream = NULL, *csubstream = NULL; unsigned int f_mode = file->f_mode; snd_assert(rpcm_oss_file != NULL, return -EINVAL); @@ -1839,9 +1839,9 @@ static int snd_pcm_oss_open(struct inode *inode, struct file *file) int device; int err; char task_name[32]; - snd_pcm_t *pcm; - snd_pcm_oss_file_t *pcm_oss_file; - snd_pcm_oss_setup_t *psetup = NULL, *csetup = NULL; + struct snd_pcm *pcm; + struct snd_pcm_oss_file *pcm_oss_file; + struct snd_pcm_oss_setup *psetup = NULL, *csetup = NULL; int nonblock; wait_queue_t wait; @@ -1925,9 +1925,9 @@ static int snd_pcm_oss_open(struct inode *inode, struct file *file) static int snd_pcm_oss_release(struct inode *inode, struct file *file) { - snd_pcm_t *pcm; - snd_pcm_substream_t *substream; - snd_pcm_oss_file_t *pcm_oss_file; + struct snd_pcm *pcm; + struct snd_pcm_substream *substream; + struct snd_pcm_oss_file *pcm_oss_file; pcm_oss_file = file->private_data; substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_PLAYBACK]; @@ -1947,7 +1947,7 @@ static int snd_pcm_oss_release(struct inode *inode, struct file *file) static long snd_pcm_oss_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { - snd_pcm_oss_file_t *pcm_oss_file; + struct snd_pcm_oss_file *pcm_oss_file; int __user *p = (int __user *)arg; int res; @@ -1958,7 +1958,7 @@ static long snd_pcm_oss_ioctl(struct file *file, unsigned int cmd, unsigned long return put_user(1, p); #if defined(CONFIG_SND_MIXER_OSS) || (defined(MODULE) && defined(CONFIG_SND_MIXER_OSS_MODULE)) if (((cmd >> 8) & 0xff) == 'M') { /* mixer ioctl - for OSS compatibility */ - snd_pcm_substream_t *substream; + struct snd_pcm_substream *substream; int idx; for (idx = 0; idx < 2; ++idx) { substream = pcm_oss_file->streams[idx]; @@ -2113,8 +2113,8 @@ static long snd_pcm_oss_ioctl(struct file *file, unsigned int cmd, unsigned long static ssize_t snd_pcm_oss_read(struct file *file, char __user *buf, size_t count, loff_t *offset) { - snd_pcm_oss_file_t *pcm_oss_file; - snd_pcm_substream_t *substream; + struct snd_pcm_oss_file *pcm_oss_file; + struct snd_pcm_substream *substream; pcm_oss_file = file->private_data; substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_CAPTURE]; @@ -2133,8 +2133,8 @@ static ssize_t snd_pcm_oss_read(struct file *file, char __user *buf, size_t coun static ssize_t snd_pcm_oss_write(struct file *file, const char __user *buf, size_t count, loff_t *offset) { - snd_pcm_oss_file_t *pcm_oss_file; - snd_pcm_substream_t *substream; + struct snd_pcm_oss_file *pcm_oss_file; + struct snd_pcm_substream *substream; long result; pcm_oss_file = file->private_data; @@ -2150,18 +2150,18 @@ static ssize_t snd_pcm_oss_write(struct file *file, const char __user *buf, size return result; } -static int snd_pcm_oss_playback_ready(snd_pcm_substream_t *substream) +static int snd_pcm_oss_playback_ready(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; if (atomic_read(&runtime->mmap_count)) return runtime->oss.prev_hw_ptr_interrupt != runtime->hw_ptr_interrupt; else return snd_pcm_playback_avail(runtime) >= runtime->oss.period_frames; } -static int snd_pcm_oss_capture_ready(snd_pcm_substream_t *substream) +static int snd_pcm_oss_capture_ready(struct snd_pcm_substream *substream) { - snd_pcm_runtime_t *runtime = substream->runtime; + struct snd_pcm_runtime *runtime = substream->runtime; if (atomic_read(&runtime->mmap_count)) return runtime->oss.prev_hw_ptr_interrupt != runtime->hw_ptr_interrupt; else @@ -2170,9 +2170,9 @@ static int snd_pcm_oss_capture_ready(snd_pcm_substream_t *substream) static unsigned int snd_pcm_oss_poll(struct file *file, poll_table * wait) { - snd_pcm_oss_file_t *pcm_oss_file; + struct snd_pcm_oss_file *pcm_oss_file; unsigned int mask; - snd_pcm_substream_t *psubstream = NULL, *csubstream = NULL; + struct snd_pcm_substream *psubstream = NULL, *csubstream = NULL; pcm_oss_file = file->private_data; @@ -2181,7 +2181,7 @@ static unsigned int snd_pcm_oss_poll(struct file *file, poll_table * wait) mask = 0; if (psubstream != NULL) { - snd_pcm_runtime_t *runtime = psubstream->runtime; + struct snd_pcm_runtime *runtime = psubstream->runtime; poll_wait(file, &runtime->sleep, wait); snd_pcm_stream_lock_irq(psubstream); if (runtime->status->state != SNDRV_PCM_STATE_DRAINING && @@ -2191,8 +2191,8 @@ static unsigned int snd_pcm_oss_poll(struct file *file, poll_table * wait) snd_pcm_stream_unlock_irq(psubstream); } if (csubstream != NULL) { - snd_pcm_runtime_t *runtime = csubstream->runtime; - enum sndrv_pcm_state ostate; + struct snd_pcm_runtime *runtime = csubstream->runtime; + snd_pcm_state_t ostate; poll_wait(file, &runtime->sleep, wait); snd_pcm_stream_lock_irq(csubstream); if ((ostate = runtime->status->state) != SNDRV_PCM_STATE_RUNNING || @@ -2200,7 +2200,7 @@ static unsigned int snd_pcm_oss_poll(struct file *file, poll_table * wait) mask |= POLLIN | POLLRDNORM; snd_pcm_stream_unlock_irq(csubstream); if (ostate != SNDRV_PCM_STATE_RUNNING && runtime->oss.trigger) { - snd_pcm_oss_file_t ofile; + struct snd_pcm_oss_file ofile; memset(&ofile, 0, sizeof(ofile)); ofile.streams[SNDRV_PCM_STREAM_CAPTURE] = pcm_oss_file->streams[SNDRV_PCM_STREAM_CAPTURE]; runtime->oss.trigger = 0; @@ -2213,9 +2213,9 @@ static unsigned int snd_pcm_oss_poll(struct file *file, poll_table * wait) static int snd_pcm_oss_mmap(struct file *file, struct vm_area_struct *area) { - snd_pcm_oss_file_t *pcm_oss_file; - snd_pcm_substream_t *substream = NULL; - snd_pcm_runtime_t *runtime; + struct snd_pcm_oss_file *pcm_oss_file; + struct snd_pcm_substream *substream = NULL; + struct snd_pcm_runtime *runtime; int err; #ifdef OSS_DEBUG @@ -2279,11 +2279,11 @@ static int snd_pcm_oss_mmap(struct file *file, struct vm_area_struct *area) * /proc interface */ -static void snd_pcm_oss_proc_read(snd_info_entry_t *entry, - snd_info_buffer_t * buffer) +static void snd_pcm_oss_proc_read(struct snd_info_entry *entry, + struct snd_info_buffer *buffer) { - snd_pcm_str_t *pstr = (snd_pcm_str_t *)entry->private_data; - snd_pcm_oss_setup_t *setup = pstr->oss.setup_list; + struct snd_pcm_str *pstr = entry->private_data; + struct snd_pcm_oss_setup *setup = pstr->oss.setup_list; down(&pstr->oss.setup_mutex); while (setup) { snd_iprintf(buffer, "%s %u %u%s%s%s%s%s%s\n", @@ -2301,11 +2301,11 @@ static void snd_pcm_oss_proc_read(snd_info_entry_t *entry, up(&pstr->oss.setup_mutex); } -static void snd_pcm_oss_proc_free_setup_list(snd_pcm_str_t * pstr) +static void snd_pcm_oss_proc_free_setup_list(struct snd_pcm_str * pstr) { unsigned int idx; - snd_pcm_substream_t *substream; - snd_pcm_oss_setup_t *setup, *setupn; + struct snd_pcm_substream *substream; + struct snd_pcm_oss_setup *setup, *setupn; for (idx = 0, substream = pstr->substream; idx < pstr->substream_count; idx++, substream = substream->next) @@ -2319,13 +2319,13 @@ static void snd_pcm_oss_proc_free_setup_list(snd_pcm_str_t * pstr) pstr->oss.setup_list = NULL; } -static void snd_pcm_oss_proc_write(snd_info_entry_t *entry, - snd_info_buffer_t * buffer) +static void snd_pcm_oss_proc_write(struct snd_info_entry *entry, + struct snd_info_buffer *buffer) { - snd_pcm_str_t *pstr = (snd_pcm_str_t *)entry->private_data; + struct snd_pcm_str *pstr = entry->private_data; char line[128], str[32], task_name[32], *ptr; int idx1; - snd_pcm_oss_setup_t *setup, *setup1, template; + struct snd_pcm_oss_setup *setup, *setup1, template; while (!snd_info_get_line(buffer, line, sizeof(line))) { down(&pstr->oss.setup_mutex); @@ -2370,7 +2370,7 @@ static void snd_pcm_oss_proc_write(snd_info_entry_t *entry, } } while (*str); if (setup == NULL) { - setup = (snd_pcm_oss_setup_t *) kmalloc(sizeof(snd_pcm_oss_setup_t), GFP_KERNEL); + setup = kmalloc(sizeof(struct snd_pcm_oss_setup), GFP_KERNEL); if (setup) { if (pstr->oss.setup_list == NULL) { pstr->oss.setup_list = setup; @@ -2389,12 +2389,12 @@ static void snd_pcm_oss_proc_write(snd_info_entry_t *entry, } } -static void snd_pcm_oss_proc_init(snd_pcm_t *pcm) +static void snd_pcm_oss_proc_init(struct snd_pcm *pcm) { int stream; for (stream = 0; stream < 2; ++stream) { - snd_info_entry_t *entry; - snd_pcm_str_t *pstr = &pcm->streams[stream]; + struct snd_info_entry *entry; + struct snd_pcm_str *pstr = &pcm->streams[stream]; if (pstr->substream_count == 0) continue; if ((entry = snd_info_create_card_entry(pcm->card, "oss", pstr->proc_root)) != NULL) { @@ -2414,11 +2414,11 @@ static void snd_pcm_oss_proc_init(snd_pcm_t *pcm) } } -static void snd_pcm_oss_proc_done(snd_pcm_t *pcm) +static void snd_pcm_oss_proc_done(struct snd_pcm *pcm) { int stream; for (stream = 0; stream < 2; ++stream) { - snd_pcm_str_t *pstr = &pcm->streams[stream]; + struct snd_pcm_str *pstr = &pcm->streams[stream]; if (pstr->oss.proc_entry) { snd_info_unregister(pstr->oss.proc_entry); pstr->oss.proc_entry = NULL; @@ -2444,13 +2444,13 @@ static struct file_operations snd_pcm_oss_f_reg = .mmap = snd_pcm_oss_mmap, }; -static snd_minor_t snd_pcm_oss_reg = +static struct snd_minor snd_pcm_oss_reg = { .comment = "digital audio", .f_ops = &snd_pcm_oss_f_reg, }; -static void register_oss_dsp(snd_pcm_t *pcm, int index) +static void register_oss_dsp(struct snd_pcm *pcm, int index) { char name[128]; sprintf(name, "dsp%i%i", pcm->card->number, pcm->device); @@ -2462,7 +2462,7 @@ static void register_oss_dsp(snd_pcm_t *pcm, int index) } } -static int snd_pcm_oss_register_minor(snd_pcm_t * pcm) +static int snd_pcm_oss_register_minor(struct snd_pcm *pcm) { pcm->oss.reg = 0; if (dsp_map[pcm->card->number] == (int)pcm->device) { @@ -2493,7 +2493,7 @@ static int snd_pcm_oss_register_minor(snd_pcm_t * pcm) return 0; } -static int snd_pcm_oss_disconnect_minor(snd_pcm_t * pcm) +static int snd_pcm_oss_disconnect_minor(struct snd_pcm *pcm) { if (pcm->oss.reg) { if (pcm->oss.reg_mask & 1) { @@ -2510,7 +2510,7 @@ static int snd_pcm_oss_disconnect_minor(snd_pcm_t * pcm) return 0; } -static int snd_pcm_oss_unregister_minor(snd_pcm_t * pcm) +static int snd_pcm_oss_unregister_minor(struct snd_pcm *pcm) { snd_pcm_oss_disconnect_minor(pcm); if (pcm->oss.reg) { @@ -2525,7 +2525,7 @@ static int snd_pcm_oss_unregister_minor(snd_pcm_t * pcm) return 0; } -static snd_pcm_notify_t snd_pcm_oss_notify = +static struct snd_pcm_notify snd_pcm_oss_notify = { .n_register = snd_pcm_oss_register_minor, .n_disconnect = snd_pcm_oss_disconnect_minor, diff --git a/sound/core/oss/pcm_plugin.c b/sound/core/oss/pcm_plugin.c index 312ae1f2bfc3..7e8676880dde 100644 --- a/sound/core/oss/pcm_plugin.c +++ b/sound/core/oss/pcm_plugin.c @@ -36,7 +36,7 @@ #define snd_pcm_plug_first(plug) ((plug)->runtime->oss.plugin_first) #define snd_pcm_plug_last(plug) ((plug)->runtime->oss.plugin_last) -static int snd_pcm_plugin_src_channels_mask(snd_pcm_plugin_t *plugin, +static int snd_pcm_plugin_src_channels_mask(struct snd_pcm_plugin *plugin, unsigned long *dst_vmask, unsigned long **src_vmask) { @@ -46,7 +46,7 @@ static int snd_pcm_plugin_src_channels_mask(snd_pcm_plugin_t *plugin, return 0; } -static int snd_pcm_plugin_dst_channels_mask(snd_pcm_plugin_t *plugin, +static int snd_pcm_plugin_dst_channels_mask(struct snd_pcm_plugin *plugin, unsigned long *src_vmask, unsigned long **dst_vmask) { @@ -67,13 +67,13 @@ static int rate_match(unsigned int src_rate, unsigned int dst_rate) return dst_rate >= low && dst_rate <= high; } -static int snd_pcm_plugin_alloc(snd_pcm_plugin_t *plugin, snd_pcm_uframes_t frames) +static int snd_pcm_plugin_alloc(struct snd_pcm_plugin *plugin, snd_pcm_uframes_t frames) { - snd_pcm_plugin_format_t *format; + struct snd_pcm_plugin_format *format; ssize_t width; size_t size; unsigned int channel; - snd_pcm_plugin_channel_t *c; + struct snd_pcm_plugin_channel *c; if (plugin->stream == SNDRV_PCM_STREAM_PLAYBACK) { format = &plugin->src_format; @@ -120,12 +120,12 @@ static int snd_pcm_plugin_alloc(snd_pcm_plugin_t *plugin, snd_pcm_uframes_t fram return 0; } -int snd_pcm_plug_alloc(snd_pcm_plug_t *plug, snd_pcm_uframes_t frames) +int snd_pcm_plug_alloc(struct snd_pcm_substream *plug, snd_pcm_uframes_t frames) { int err; snd_assert(snd_pcm_plug_first(plug) != NULL, return -ENXIO); if (snd_pcm_plug_stream(plug) == SNDRV_PCM_STREAM_PLAYBACK) { - snd_pcm_plugin_t *plugin = snd_pcm_plug_first(plug); + struct snd_pcm_plugin *plugin = snd_pcm_plug_first(plug); while (plugin->next) { if (plugin->dst_frames) frames = plugin->dst_frames(plugin, frames); @@ -136,7 +136,7 @@ int snd_pcm_plug_alloc(snd_pcm_plug_t *plug, snd_pcm_uframes_t frames) return err; } } else { - snd_pcm_plugin_t *plugin = snd_pcm_plug_last(plug); + struct snd_pcm_plugin *plugin = snd_pcm_plug_last(plug); while (plugin->prev) { if (plugin->src_frames) frames = plugin->src_frames(plugin, frames); @@ -151,22 +151,22 @@ int snd_pcm_plug_alloc(snd_pcm_plug_t *plug, snd_pcm_uframes_t frames) } -snd_pcm_sframes_t snd_pcm_plugin_client_channels(snd_pcm_plugin_t *plugin, +snd_pcm_sframes_t snd_pcm_plugin_client_channels(struct snd_pcm_plugin *plugin, snd_pcm_uframes_t frames, - snd_pcm_plugin_channel_t **channels) + struct snd_pcm_plugin_channel **channels) { *channels = plugin->buf_channels; return frames; } -int snd_pcm_plugin_build(snd_pcm_plug_t *plug, +int snd_pcm_plugin_build(struct snd_pcm_substream *plug, const char *name, - snd_pcm_plugin_format_t *src_format, - snd_pcm_plugin_format_t *dst_format, + struct snd_pcm_plugin_format *src_format, + struct snd_pcm_plugin_format *dst_format, size_t extra, - snd_pcm_plugin_t **ret) + struct snd_pcm_plugin **ret) { - snd_pcm_plugin_t *plugin; + struct snd_pcm_plugin *plugin; unsigned int channels; snd_assert(plug != NULL, return -ENXIO); @@ -210,7 +210,7 @@ int snd_pcm_plugin_build(snd_pcm_plug_t *plug, return 0; } -int snd_pcm_plugin_free(snd_pcm_plugin_t *plugin) +int snd_pcm_plugin_free(struct snd_pcm_plugin *plugin) { if (! plugin) return 0; @@ -224,9 +224,9 @@ int snd_pcm_plugin_free(snd_pcm_plugin_t *plugin) return 0; } -snd_pcm_sframes_t snd_pcm_plug_client_size(snd_pcm_plug_t *plug, snd_pcm_uframes_t drv_frames) +snd_pcm_sframes_t snd_pcm_plug_client_size(struct snd_pcm_substream *plug, snd_pcm_uframes_t drv_frames) { - snd_pcm_plugin_t *plugin, *plugin_prev, *plugin_next; + struct snd_pcm_plugin *plugin, *plugin_prev, *plugin_next; int stream = snd_pcm_plug_stream(plug); snd_assert(plug != NULL, return -ENXIO); @@ -253,9 +253,9 @@ snd_pcm_sframes_t snd_pcm_plug_client_size(snd_pcm_plug_t *plug, snd_pcm_uframes return drv_frames; } -snd_pcm_sframes_t snd_pcm_plug_slave_size(snd_pcm_plug_t *plug, snd_pcm_uframes_t clt_frames) +snd_pcm_sframes_t snd_pcm_plug_slave_size(struct snd_pcm_substream *plug, snd_pcm_uframes_t clt_frames) { - snd_pcm_plugin_t *plugin, *plugin_prev, *plugin_next; + struct snd_pcm_plugin *plugin, *plugin_prev, *plugin_next; snd_pcm_sframes_t frames; int stream = snd_pcm_plug_stream(plug); @@ -290,9 +290,9 @@ snd_pcm_sframes_t snd_pcm_plug_slave_size(snd_pcm_plug_t *plug, snd_pcm_uframes_ return frames; } -static int snd_pcm_plug_formats(snd_mask_t *mask, int format) +static int snd_pcm_plug_formats(struct snd_mask *mask, int format) { - snd_mask_t formats = *mask; + struct snd_mask formats = *mask; u64 linfmts = (SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE | SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_U16_BE | SNDRV_PCM_FMTBIT_S16_BE | @@ -326,7 +326,7 @@ static int preferred_formats[] = { SNDRV_PCM_FORMAT_U8 }; -int snd_pcm_plug_slave_format(int format, snd_mask_t *format_mask) +int snd_pcm_plug_slave_format(int format, struct snd_mask *format_mask) { if (snd_mask_test(format_mask, format)) return format; @@ -376,15 +376,15 @@ int snd_pcm_plug_slave_format(int format, snd_mask_t *format_mask) } } -int snd_pcm_plug_format_plugins(snd_pcm_plug_t *plug, - snd_pcm_hw_params_t *params, - snd_pcm_hw_params_t *slave_params) +int snd_pcm_plug_format_plugins(struct snd_pcm_substream *plug, + struct snd_pcm_hw_params *params, + struct snd_pcm_hw_params *slave_params) { - snd_pcm_plugin_format_t tmpformat; - snd_pcm_plugin_format_t dstformat; - snd_pcm_plugin_format_t srcformat; + struct snd_pcm_plugin_format tmpformat; + struct snd_pcm_plugin_format dstformat; + struct snd_pcm_plugin_format srcformat; int src_access, dst_access; - snd_pcm_plugin_t *plugin = NULL; + struct snd_pcm_plugin *plugin = NULL; int err; int stream = snd_pcm_plug_stream(plug); int slave_interleaved = (params_channels(slave_params) == 1 || @@ -462,7 +462,7 @@ int snd_pcm_plug_format_plugins(snd_pcm_plug_t *plug, if (srcformat.channels > dstformat.channels) { int sv = srcformat.channels; int dv = dstformat.channels; - route_ttable_entry_t *ttable = kcalloc(dv * sv, sizeof(*ttable), GFP_KERNEL); + int *ttable = kcalloc(dv * sv, sizeof(*ttable), GFP_KERNEL); if (ttable == NULL) return -ENOMEM; #if 1 @@ -525,7 +525,7 @@ int snd_pcm_plug_format_plugins(snd_pcm_plug_t *plug, if (srcformat.channels < dstformat.channels) { int sv = srcformat.channels; int dv = dstformat.channels; - route_ttable_entry_t *ttable = kcalloc(dv * sv, sizeof(*ttable), GFP_KERNEL); + int *ttable = kcalloc(dv * sv, sizeof(*ttable), GFP_KERNEL); if (ttable == NULL) return -ENOMEM; #if 0 @@ -614,14 +614,14 @@ int snd_pcm_plug_format_plugins(snd_pcm_plug_t *plug, return 0; } -snd_pcm_sframes_t snd_pcm_plug_client_channels_buf(snd_pcm_plug_t *plug, +snd_pcm_sframes_t snd_pcm_plug_client_channels_buf(struct snd_pcm_substream *plug, char *buf, snd_pcm_uframes_t count, - snd_pcm_plugin_channel_t **channels) + struct snd_pcm_plugin_channel **channels) { - snd_pcm_plugin_t *plugin; - snd_pcm_plugin_channel_t *v; - snd_pcm_plugin_format_t *format; + struct snd_pcm_plugin *plugin; + struct snd_pcm_plugin_channel *v; + struct snd_pcm_plugin_format *format; int width, nchannels, channel; int stream = snd_pcm_plug_stream(plug); @@ -650,10 +650,10 @@ snd_pcm_sframes_t snd_pcm_plug_client_channels_buf(snd_pcm_plug_t *plug, return count; } -static int snd_pcm_plug_playback_channels_mask(snd_pcm_plug_t *plug, +static int snd_pcm_plug_playback_channels_mask(struct snd_pcm_substream *plug, unsigned long *client_vmask) { - snd_pcm_plugin_t *plugin = snd_pcm_plug_last(plug); + struct snd_pcm_plugin *plugin = snd_pcm_plug_last(plug); if (plugin == NULL) { return 0; } else { @@ -678,10 +678,10 @@ static int snd_pcm_plug_playback_channels_mask(snd_pcm_plug_t *plug, } } -static int snd_pcm_plug_playback_disable_useless_channels(snd_pcm_plug_t *plug, - snd_pcm_plugin_channel_t *src_channels) +static int snd_pcm_plug_playback_disable_useless_channels(struct snd_pcm_substream *plug, + struct snd_pcm_plugin_channel *src_channels) { - snd_pcm_plugin_t *plugin = snd_pcm_plug_first(plug); + struct snd_pcm_plugin *plugin = snd_pcm_plug_first(plug); unsigned int nchannels = plugin->src_format.channels; DECLARE_BITMAP(bs, nchannels); unsigned long *srcmask = bs; @@ -703,11 +703,11 @@ static int snd_pcm_plug_playback_disable_useless_channels(snd_pcm_plug_t *plug, return 0; } -static int snd_pcm_plug_capture_disable_useless_channels(snd_pcm_plug_t *plug, - snd_pcm_plugin_channel_t *src_channels, - snd_pcm_plugin_channel_t *client_channels) +static int snd_pcm_plug_capture_disable_useless_channels(struct snd_pcm_substream *plug, + struct snd_pcm_plugin_channel *src_channels, + struct snd_pcm_plugin_channel *client_channels) { - snd_pcm_plugin_t *plugin = snd_pcm_plug_last(plug); + struct snd_pcm_plugin *plugin = snd_pcm_plug_last(plug); unsigned int nchannels = plugin->dst_format.channels; DECLARE_BITMAP(bs, nchannels); unsigned long *dstmask = bs; @@ -736,10 +736,10 @@ static int snd_pcm_plug_capture_disable_useless_channels(snd_pcm_plug_t *plug, return 0; } -snd_pcm_sframes_t snd_pcm_plug_write_transfer(snd_pcm_plug_t *plug, snd_pcm_plugin_channel_t *src_channels, snd_pcm_uframes_t size) +snd_pcm_sframes_t snd_pcm_plug_write_transfer(struct snd_pcm_substream *plug, struct snd_pcm_plugin_channel *src_channels, snd_pcm_uframes_t size) { - snd_pcm_plugin_t *plugin, *next; - snd_pcm_plugin_channel_t *dst_channels; + struct snd_pcm_plugin *plugin, *next; + struct snd_pcm_plugin_channel *dst_channels; int err; snd_pcm_sframes_t frames = size; @@ -771,10 +771,10 @@ snd_pcm_sframes_t snd_pcm_plug_write_transfer(snd_pcm_plug_t *plug, snd_pcm_plug return snd_pcm_plug_client_size(plug, frames); } -snd_pcm_sframes_t snd_pcm_plug_read_transfer(snd_pcm_plug_t *plug, snd_pcm_plugin_channel_t *dst_channels_final, snd_pcm_uframes_t size) +snd_pcm_sframes_t snd_pcm_plug_read_transfer(struct snd_pcm_substream *plug, struct snd_pcm_plugin_channel *dst_channels_final, snd_pcm_uframes_t size) { - snd_pcm_plugin_t *plugin, *next; - snd_pcm_plugin_channel_t *src_channels, *dst_channels; + struct snd_pcm_plugin *plugin, *next; + struct snd_pcm_plugin_channel *src_channels, *dst_channels; snd_pcm_sframes_t frames = size; int err; @@ -806,7 +806,7 @@ snd_pcm_sframes_t snd_pcm_plug_read_transfer(snd_pcm_plug_t *plug, snd_pcm_plugi return frames; } -int snd_pcm_area_silence(const snd_pcm_channel_area_t *dst_area, size_t dst_offset, +int snd_pcm_area_silence(const struct snd_pcm_channel_area *dst_area, size_t dst_offset, size_t samples, int format) { /* FIXME: sub byte resolution and odd dst_offset */ @@ -852,8 +852,8 @@ int snd_pcm_area_silence(const snd_pcm_channel_area_t *dst_area, size_t dst_offs return 0; } -int snd_pcm_area_copy(const snd_pcm_channel_area_t *src_area, size_t src_offset, - const snd_pcm_channel_area_t *dst_area, size_t dst_offset, +int snd_pcm_area_copy(const struct snd_pcm_channel_area *src_area, size_t src_offset, + const struct snd_pcm_channel_area *dst_area, size_t dst_offset, size_t samples, int format) { /* FIXME: sub byte resolution and odd dst_offset */ diff --git a/sound/core/oss/pcm_plugin.h b/sound/core/oss/pcm_plugin.h index 69a43172142c..29198da615cd 100644 --- a/sound/core/oss/pcm_plugin.h +++ b/sound/core/oss/pcm_plugin.h @@ -29,147 +29,157 @@ static inline unsigned long *bitmap_alloc(unsigned int nbits) return kmalloc(BITS_TO_LONGS(nbits), GFP_KERNEL); } -#define snd_pcm_plug_t snd_pcm_substream_t #define snd_pcm_plug_stream(plug) ((plug)->stream) -typedef enum { +enum snd_pcm_plugin_action { INIT = 0, PREPARE = 1, -} snd_pcm_plugin_action_t; +}; -typedef struct _snd_pcm_channel_area { +struct snd_pcm_channel_area { void *addr; /* base address of channel samples */ unsigned int first; /* offset to first sample in bits */ unsigned int step; /* samples distance in bits */ -} snd_pcm_channel_area_t; +}; -typedef struct _snd_pcm_plugin_channel { +struct snd_pcm_plugin_channel { void *aptr; /* pointer to the allocated area */ - snd_pcm_channel_area_t area; + struct snd_pcm_channel_area area; snd_pcm_uframes_t frames; /* allocated frames */ unsigned int enabled:1; /* channel need to be processed */ unsigned int wanted:1; /* channel is wanted */ -} snd_pcm_plugin_channel_t; +}; -typedef struct _snd_pcm_plugin_format { +struct snd_pcm_plugin_format { int format; unsigned int rate; unsigned int channels; -} snd_pcm_plugin_format_t; +}; -struct _snd_pcm_plugin { +struct snd_pcm_plugin { const char *name; /* plug-in name */ int stream; - snd_pcm_plugin_format_t src_format; /* source format */ - snd_pcm_plugin_format_t dst_format; /* destination format */ + struct snd_pcm_plugin_format src_format; /* source format */ + struct snd_pcm_plugin_format dst_format; /* destination format */ int src_width; /* sample width in bits */ int dst_width; /* sample width in bits */ int access; - snd_pcm_sframes_t (*src_frames)(snd_pcm_plugin_t *plugin, snd_pcm_uframes_t dst_frames); - snd_pcm_sframes_t (*dst_frames)(snd_pcm_plugin_t *plugin, snd_pcm_uframes_t src_frames); - snd_pcm_sframes_t (*client_channels)(snd_pcm_plugin_t *plugin, - snd_pcm_uframes_t frames, - snd_pcm_plugin_channel_t **channels); - int (*src_channels_mask)(snd_pcm_plugin_t *plugin, + snd_pcm_sframes_t (*src_frames)(struct snd_pcm_plugin *plugin, snd_pcm_uframes_t dst_frames); + snd_pcm_sframes_t (*dst_frames)(struct snd_pcm_plugin *plugin, snd_pcm_uframes_t src_frames); + snd_pcm_sframes_t (*client_channels)(struct snd_pcm_plugin *plugin, + snd_pcm_uframes_t frames, + struct snd_pcm_plugin_channel **channels); + int (*src_channels_mask)(struct snd_pcm_plugin *plugin, unsigned long *dst_vmask, unsigned long **src_vmask); - int (*dst_channels_mask)(snd_pcm_plugin_t *plugin, + int (*dst_channels_mask)(struct snd_pcm_plugin *plugin, unsigned long *src_vmask, unsigned long **dst_vmask); - snd_pcm_sframes_t (*transfer)(snd_pcm_plugin_t *plugin, - const snd_pcm_plugin_channel_t *src_channels, - snd_pcm_plugin_channel_t *dst_channels, - snd_pcm_uframes_t frames); - int (*action)(snd_pcm_plugin_t *plugin, - snd_pcm_plugin_action_t action, + snd_pcm_sframes_t (*transfer)(struct snd_pcm_plugin *plugin, + const struct snd_pcm_plugin_channel *src_channels, + struct snd_pcm_plugin_channel *dst_channels, + snd_pcm_uframes_t frames); + int (*action)(struct snd_pcm_plugin *plugin, + enum snd_pcm_plugin_action action, unsigned long data); - snd_pcm_plugin_t *prev; - snd_pcm_plugin_t *next; - snd_pcm_plug_t *plug; + struct snd_pcm_plugin *prev; + struct snd_pcm_plugin *next; + struct snd_pcm_substream *plug; void *private_data; - void (*private_free)(snd_pcm_plugin_t *plugin); + void (*private_free)(struct snd_pcm_plugin *plugin); char *buf; snd_pcm_uframes_t buf_frames; - snd_pcm_plugin_channel_t *buf_channels; + struct snd_pcm_plugin_channel *buf_channels; unsigned long *src_vmask; unsigned long *dst_vmask; char extra_data[0]; }; -int snd_pcm_plugin_build(snd_pcm_plug_t *handle, +int snd_pcm_plugin_build(struct snd_pcm_substream *handle, const char *name, - snd_pcm_plugin_format_t *src_format, - snd_pcm_plugin_format_t *dst_format, + struct snd_pcm_plugin_format *src_format, + struct snd_pcm_plugin_format *dst_format, size_t extra, - snd_pcm_plugin_t **ret); -int snd_pcm_plugin_free(snd_pcm_plugin_t *plugin); -int snd_pcm_plugin_clear(snd_pcm_plugin_t **first); -int snd_pcm_plug_alloc(snd_pcm_plug_t *plug, snd_pcm_uframes_t frames); -snd_pcm_sframes_t snd_pcm_plug_client_size(snd_pcm_plug_t *handle, snd_pcm_uframes_t drv_size); -snd_pcm_sframes_t snd_pcm_plug_slave_size(snd_pcm_plug_t *handle, snd_pcm_uframes_t clt_size); + struct snd_pcm_plugin **ret); +int snd_pcm_plugin_free(struct snd_pcm_plugin *plugin); +int snd_pcm_plugin_clear(struct snd_pcm_plugin **first); +int snd_pcm_plug_alloc(struct snd_pcm_substream *plug, snd_pcm_uframes_t frames); +snd_pcm_sframes_t snd_pcm_plug_client_size(struct snd_pcm_substream *handle, snd_pcm_uframes_t drv_size); +snd_pcm_sframes_t snd_pcm_plug_slave_size(struct snd_pcm_substream *handle, snd_pcm_uframes_t clt_size); #define FULL ROUTE_PLUGIN_RESOLUTION #define HALF ROUTE_PLUGIN_RESOLUTION / 2 -typedef int route_ttable_entry_t; - -int snd_pcm_plugin_build_io(snd_pcm_plug_t *handle, - snd_pcm_hw_params_t *params, - snd_pcm_plugin_t **r_plugin); -int snd_pcm_plugin_build_linear(snd_pcm_plug_t *handle, - snd_pcm_plugin_format_t *src_format, - snd_pcm_plugin_format_t *dst_format, - snd_pcm_plugin_t **r_plugin); -int snd_pcm_plugin_build_mulaw(snd_pcm_plug_t *handle, - snd_pcm_plugin_format_t *src_format, - snd_pcm_plugin_format_t *dst_format, - snd_pcm_plugin_t **r_plugin); -int snd_pcm_plugin_build_rate(snd_pcm_plug_t *handle, - snd_pcm_plugin_format_t *src_format, - snd_pcm_plugin_format_t *dst_format, - snd_pcm_plugin_t **r_plugin); -int snd_pcm_plugin_build_route(snd_pcm_plug_t *handle, - snd_pcm_plugin_format_t *src_format, - snd_pcm_plugin_format_t *dst_format, - route_ttable_entry_t *ttable, - snd_pcm_plugin_t **r_plugin); -int snd_pcm_plugin_build_copy(snd_pcm_plug_t *handle, - snd_pcm_plugin_format_t *src_format, - snd_pcm_plugin_format_t *dst_format, - snd_pcm_plugin_t **r_plugin); - -int snd_pcm_plug_format_plugins(snd_pcm_plug_t *substream, - snd_pcm_hw_params_t *params, - snd_pcm_hw_params_t *slave_params); - -int snd_pcm_plug_slave_format(int format, snd_mask_t *format_mask); - -int snd_pcm_plugin_append(snd_pcm_plugin_t *plugin); - -snd_pcm_sframes_t snd_pcm_plug_write_transfer(snd_pcm_plug_t *handle, snd_pcm_plugin_channel_t *src_channels, snd_pcm_uframes_t size); -snd_pcm_sframes_t snd_pcm_plug_read_transfer(snd_pcm_plug_t *handle, snd_pcm_plugin_channel_t *dst_channels_final, snd_pcm_uframes_t size); - -snd_pcm_sframes_t snd_pcm_plug_client_channels_buf(snd_pcm_plug_t *handle, - char *buf, snd_pcm_uframes_t count, - snd_pcm_plugin_channel_t **channels); - -snd_pcm_sframes_t snd_pcm_plugin_client_channels(snd_pcm_plugin_t *plugin, - snd_pcm_uframes_t frames, - snd_pcm_plugin_channel_t **channels); - -int snd_pcm_area_silence(const snd_pcm_channel_area_t *dst_channel, size_t dst_offset, + +int snd_pcm_plugin_build_io(struct snd_pcm_substream *handle, + struct snd_pcm_hw_params *params, + struct snd_pcm_plugin **r_plugin); +int snd_pcm_plugin_build_linear(struct snd_pcm_substream *handle, + struct snd_pcm_plugin_format *src_format, + struct snd_pcm_plugin_format *dst_format, + struct snd_pcm_plugin **r_plugin); +int snd_pcm_plugin_build_mulaw(struct snd_pcm_substream *handle, + struct snd_pcm_plugin_format *src_format, + struct snd_pcm_plugin_format *dst_format, + struct snd_pcm_plugin **r_plugin); +int snd_pcm_plugin_build_rate(struct snd_pcm_substream *handle, + struct snd_pcm_plugin_format *src_format, + struct snd_pcm_plugin_format *dst_format, + struct snd_pcm_plugin **r_plugin); +int snd_pcm_plugin_build_route(struct snd_pcm_substream *handle, + struct snd_pcm_plugin_format *src_format, + struct snd_pcm_plugin_format *dst_format, + int *ttable, + struct snd_pcm_plugin **r_plugin); +int snd_pcm_plugin_build_copy(struct snd_pcm_substream *handle, + struct snd_pcm_plugin_format *src_format, + struct snd_pcm_plugin_format *dst_format, + struct snd_pcm_plugin **r_plugin); + +int snd_pcm_plug_format_plugins(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params *params, + struct snd_pcm_hw_params *slave_params); + +int snd_pcm_plug_slave_format(int format, struct snd_mask *format_mask); + +int snd_pcm_plugin_append(struct snd_pcm_plugin *plugin); + +snd_pcm_sframes_t snd_pcm_plug_write_transfer(struct snd_pcm_substream *handle, + struct snd_pcm_plugin_channel *src_channels, + snd_pcm_uframes_t size); +snd_pcm_sframes_t snd_pcm_plug_read_transfer(struct snd_pcm_substream *handle, + struct snd_pcm_plugin_channel *dst_channels_final, + snd_pcm_uframes_t size); + +snd_pcm_sframes_t snd_pcm_plug_client_channels_buf(struct snd_pcm_substream *handle, + char *buf, snd_pcm_uframes_t count, + struct snd_pcm_plugin_channel **channels); + +snd_pcm_sframes_t snd_pcm_plugin_client_channels(struct snd_pcm_plugin *plugin, + snd_pcm_uframes_t frames, + struct snd_pcm_plugin_channel **channels); + +int snd_pcm_area_silence(const struct snd_pcm_channel_area *dst_channel, + size_t dst_offset, size_t samples, int format); -int snd_pcm_area_copy(const snd_pcm_channel_area_t *src_channel, size_t src_offset, - const snd_pcm_channel_area_t *dst_channel, size_t dst_offset, +int snd_pcm_area_copy(const struct snd_pcm_channel_area *src_channel, + size_t src_offset, + const struct snd_pcm_channel_area *dst_channel, + size_t dst_offset, size_t samples, int format); -void *snd_pcm_plug_buf_alloc(snd_pcm_plug_t *plug, snd_pcm_uframes_t size); -void snd_pcm_plug_buf_unlock(snd_pcm_plug_t *plug, void *ptr); -snd_pcm_sframes_t snd_pcm_oss_write3(snd_pcm_substream_t *substream, const char *ptr, snd_pcm_uframes_t size, int in_kernel); -snd_pcm_sframes_t snd_pcm_oss_read3(snd_pcm_substream_t *substream, char *ptr, snd_pcm_uframes_t size, int in_kernel); -snd_pcm_sframes_t snd_pcm_oss_writev3(snd_pcm_substream_t *substream, void **bufs, snd_pcm_uframes_t frames, int in_kernel); -snd_pcm_sframes_t snd_pcm_oss_readv3(snd_pcm_substream_t *substream, void **bufs, snd_pcm_uframes_t frames, int in_kernel); - - +void *snd_pcm_plug_buf_alloc(struct snd_pcm_substream *plug, snd_pcm_uframes_t size); +void snd_pcm_plug_buf_unlock(struct snd_pcm_substream *plug, void *ptr); +snd_pcm_sframes_t snd_pcm_oss_write3(struct snd_pcm_substream *substream, + const char *ptr, snd_pcm_uframes_t size, + int in_kernel); +snd_pcm_sframes_t snd_pcm_oss_read3(struct snd_pcm_substream *substream, + char *ptr, snd_pcm_uframes_t size, int in_kernel); +snd_pcm_sframes_t snd_pcm_oss_writev3(struct snd_pcm_substream *substream, + void **bufs, snd_pcm_uframes_t frames, + int in_kernel); +snd_pcm_sframes_t snd_pcm_oss_readv3(struct snd_pcm_substream *substream, + void **bufs, snd_pcm_uframes_t frames, + int in_kernel); #define ROUTE_PLUGIN_RESOLUTION 16 @@ -177,8 +187,8 @@ int getput_index(int format); int copy_index(int format); int conv_index(int src_format, int dst_format); -void zero_channel(snd_pcm_plugin_t *plugin, - const snd_pcm_plugin_channel_t *dst_channel, +void zero_channel(struct snd_pcm_plugin *plugin, + const struct snd_pcm_plugin_channel *dst_channel, size_t samples); #ifdef PLUGIN_DEBUG diff --git a/sound/core/oss/rate.c b/sound/core/oss/rate.c index 7e325ca58706..4854cef6fb4f 100644 --- a/sound/core/oss/rate.c +++ b/sound/core/oss/rate.c @@ -33,29 +33,29 @@ * Basic rate conversion plugin */ -typedef struct { +struct rate_channel { signed short last_S1; signed short last_S2; -} rate_channel_t; +}; -typedef void (*rate_f)(snd_pcm_plugin_t *plugin, - const snd_pcm_plugin_channel_t *src_channels, - snd_pcm_plugin_channel_t *dst_channels, +typedef void (*rate_f)(struct snd_pcm_plugin *plugin, + const struct snd_pcm_plugin_channel *src_channels, + struct snd_pcm_plugin_channel *dst_channels, int src_frames, int dst_frames); -typedef struct rate_private_data { +struct rate_priv { unsigned int pitch; unsigned int pos; rate_f func; int get, put; snd_pcm_sframes_t old_src_frames, old_dst_frames; - rate_channel_t channels[0]; -} rate_t; + struct rate_channel channels[0]; +}; -static void rate_init(snd_pcm_plugin_t *plugin) +static void rate_init(struct snd_pcm_plugin *plugin) { unsigned int channel; - rate_t *data = (rate_t *)plugin->extra_data; + struct rate_priv *data = (struct rate_priv *)plugin->extra_data; data->pos = 0; for (channel = 0; channel < plugin->src_format.channels; channel++) { data->channels[channel].last_S1 = 0; @@ -63,9 +63,9 @@ static void rate_init(snd_pcm_plugin_t *plugin) } } -static void resample_expand(snd_pcm_plugin_t *plugin, - const snd_pcm_plugin_channel_t *src_channels, - snd_pcm_plugin_channel_t *dst_channels, +static void resample_expand(struct snd_pcm_plugin *plugin, + const struct snd_pcm_plugin_channel *src_channels, + struct snd_pcm_plugin_channel *dst_channels, int src_frames, int dst_frames) { unsigned int pos = 0; @@ -75,8 +75,8 @@ static void resample_expand(snd_pcm_plugin_t *plugin, unsigned int channel; int src_step, dst_step; int src_frames1, dst_frames1; - rate_t *data = (rate_t *)plugin->extra_data; - rate_channel_t *rchannels = data->channels; + struct rate_priv *data = (struct rate_priv *)plugin->extra_data; + struct rate_channel *rchannels = data->channels; #define GET_S16_LABELS #define PUT_S16_LABELS @@ -139,9 +139,9 @@ static void resample_expand(snd_pcm_plugin_t *plugin, data->pos = pos; } -static void resample_shrink(snd_pcm_plugin_t *plugin, - const snd_pcm_plugin_channel_t *src_channels, - snd_pcm_plugin_channel_t *dst_channels, +static void resample_shrink(struct snd_pcm_plugin *plugin, + const struct snd_pcm_plugin_channel *src_channels, + struct snd_pcm_plugin_channel *dst_channels, int src_frames, int dst_frames) { unsigned int pos = 0; @@ -151,8 +151,8 @@ static void resample_shrink(snd_pcm_plugin_t *plugin, unsigned int channel; int src_step, dst_step; int src_frames1, dst_frames1; - rate_t *data = (rate_t *)plugin->extra_data; - rate_channel_t *rchannels = data->channels; + struct rate_priv *data = (struct rate_priv *)plugin->extra_data; + struct rate_channel *rchannels = data->channels; #define GET_S16_LABELS #define PUT_S16_LABELS @@ -216,15 +216,15 @@ static void resample_shrink(snd_pcm_plugin_t *plugin, data->pos = pos; } -static snd_pcm_sframes_t rate_src_frames(snd_pcm_plugin_t *plugin, snd_pcm_uframes_t frames) +static snd_pcm_sframes_t rate_src_frames(struct snd_pcm_plugin *plugin, snd_pcm_uframes_t frames) { - rate_t *data; + struct rate_priv *data; snd_pcm_sframes_t res; snd_assert(plugin != NULL, return -ENXIO); if (frames == 0) return 0; - data = (rate_t *)plugin->extra_data; + data = (struct rate_priv *)plugin->extra_data; if (plugin->src_format.rate < plugin->dst_format.rate) { res = (((frames * data->pitch) + (BITS/2)) >> SHIFT); } else { @@ -248,15 +248,15 @@ static snd_pcm_sframes_t rate_src_frames(snd_pcm_plugin_t *plugin, snd_pcm_ufram return res; } -static snd_pcm_sframes_t rate_dst_frames(snd_pcm_plugin_t *plugin, snd_pcm_uframes_t frames) +static snd_pcm_sframes_t rate_dst_frames(struct snd_pcm_plugin *plugin, snd_pcm_uframes_t frames) { - rate_t *data; + struct rate_priv *data; snd_pcm_sframes_t res; snd_assert(plugin != NULL, return -ENXIO); if (frames == 0) return 0; - data = (rate_t *)plugin->extra_data; + data = (struct rate_priv *)plugin->extra_data; if (plugin->src_format.rate < plugin->dst_format.rate) { res = (((frames << SHIFT) + (data->pitch / 2)) / data->pitch); } else { @@ -280,13 +280,13 @@ static snd_pcm_sframes_t rate_dst_frames(snd_pcm_plugin_t *plugin, snd_pcm_ufram return res; } -static snd_pcm_sframes_t rate_transfer(snd_pcm_plugin_t *plugin, - const snd_pcm_plugin_channel_t *src_channels, - snd_pcm_plugin_channel_t *dst_channels, +static snd_pcm_sframes_t rate_transfer(struct snd_pcm_plugin *plugin, + const struct snd_pcm_plugin_channel *src_channels, + struct snd_pcm_plugin_channel *dst_channels, snd_pcm_uframes_t frames) { snd_pcm_uframes_t dst_frames; - rate_t *data; + struct rate_priv *data; snd_assert(plugin != NULL && src_channels != NULL && dst_channels != NULL, return -ENXIO); if (frames == 0) @@ -308,13 +308,13 @@ static snd_pcm_sframes_t rate_transfer(snd_pcm_plugin_t *plugin, dst_frames = rate_dst_frames(plugin, frames); if (dst_frames > dst_channels[0].frames) dst_frames = dst_channels[0].frames; - data = (rate_t *)plugin->extra_data; + data = (struct rate_priv *)plugin->extra_data; data->func(plugin, src_channels, dst_channels, frames, dst_frames); return dst_frames; } -static int rate_action(snd_pcm_plugin_t *plugin, - snd_pcm_plugin_action_t action, +static int rate_action(struct snd_pcm_plugin *plugin, + enum snd_pcm_plugin_action action, unsigned long udata) { snd_assert(plugin != NULL, return -ENXIO); @@ -329,14 +329,14 @@ static int rate_action(snd_pcm_plugin_t *plugin, return 0; /* silenty ignore other actions */ } -int snd_pcm_plugin_build_rate(snd_pcm_plug_t *plug, - snd_pcm_plugin_format_t *src_format, - snd_pcm_plugin_format_t *dst_format, - snd_pcm_plugin_t **r_plugin) +int snd_pcm_plugin_build_rate(struct snd_pcm_substream *plug, + struct snd_pcm_plugin_format *src_format, + struct snd_pcm_plugin_format *dst_format, + struct snd_pcm_plugin **r_plugin) { int err; - rate_t *data; - snd_pcm_plugin_t *plugin; + struct rate_priv *data; + struct snd_pcm_plugin *plugin; snd_assert(r_plugin != NULL, return -ENXIO); *r_plugin = NULL; @@ -349,11 +349,12 @@ int snd_pcm_plugin_build_rate(snd_pcm_plug_t *plug, err = snd_pcm_plugin_build(plug, "rate conversion", src_format, dst_format, - sizeof(rate_t) + src_format->channels * sizeof(rate_channel_t), + sizeof(struct rate_priv) + + src_format->channels * sizeof(struct rate_channel), &plugin); if (err < 0) return err; - data = (rate_t *)plugin->extra_data; + data = (struct rate_priv *)plugin->extra_data; data->get = getput_index(src_format->format); snd_assert(data->get >= 0 && data->get < 4*2*2, return -EINVAL); data->put = getput_index(dst_format->format); diff --git a/sound/core/oss/route.c b/sound/core/oss/route.c index 7519aed757cd..726c5caa3fdb 100644 --- a/sound/core/oss/route.c +++ b/sound/core/oss/route.c @@ -35,61 +35,62 @@ #error "Add some code here" #endif -typedef struct ttable_dst ttable_dst_t; -typedef struct route_private_data route_t; +struct ttable_dst; -typedef void (*route_channel_f)(snd_pcm_plugin_t *plugin, - const snd_pcm_plugin_channel_t *src_channels, - snd_pcm_plugin_channel_t *dst_channel, - ttable_dst_t* ttable, snd_pcm_uframes_t frames); +typedef void (*route_channel_f)(struct snd_pcm_plugin *plugin, + const struct snd_pcm_plugin_channel *src_channels, + struct snd_pcm_plugin_channel *dst_channel, + struct ttable_dst *ttable, snd_pcm_uframes_t frames); -typedef struct { +struct ttable_src { int channel; int as_int; -} ttable_src_t; +}; struct ttable_dst { int att; /* Attenuated */ unsigned int nsrcs; - ttable_src_t* srcs; + struct ttable_src *srcs; route_channel_f func; }; -struct route_private_data { +struct route_priv { enum {R_UINT32=0, R_UINT64=1} sum_type; int get, put; int conv; int src_sample_size; - ttable_dst_t ttable[0]; + struct ttable_dst ttable[0]; }; -typedef union { +union sum { u_int32_t as_uint32; u_int64_t as_uint64; -} sum_t; +}; -static void route_to_channel_from_zero(snd_pcm_plugin_t *plugin, - const snd_pcm_plugin_channel_t *src_channels, - snd_pcm_plugin_channel_t *dst_channel, - ttable_dst_t* ttable, snd_pcm_uframes_t frames) +static void route_to_channel_from_zero(struct snd_pcm_plugin *plugin, + const struct snd_pcm_plugin_channel *src_channels, + struct snd_pcm_plugin_channel *dst_channel, + struct ttable_dst *ttable, + snd_pcm_uframes_t frames) { if (dst_channel->wanted) snd_pcm_area_silence(&dst_channel->area, 0, frames, plugin->dst_format.format); dst_channel->enabled = 0; } -static void route_to_channel_from_one(snd_pcm_plugin_t *plugin, - const snd_pcm_plugin_channel_t *src_channels, - snd_pcm_plugin_channel_t *dst_channel, - ttable_dst_t* ttable, snd_pcm_uframes_t frames) +static void route_to_channel_from_one(struct snd_pcm_plugin *plugin, + const struct snd_pcm_plugin_channel *src_channels, + struct snd_pcm_plugin_channel *dst_channel, + struct ttable_dst *ttable, + snd_pcm_uframes_t frames) { #define CONV_LABELS #include "plugin_ops.h" #undef CONV_LABELS - route_t *data = (route_t *)plugin->extra_data; + struct route_priv *data = (struct route_priv *)plugin->extra_data; void *conv; - const snd_pcm_plugin_channel_t *src_channel = NULL; + const struct snd_pcm_plugin_channel *src_channel = NULL; unsigned int srcidx; char *src, *dst; int src_step, dst_step; @@ -120,10 +121,10 @@ static void route_to_channel_from_one(snd_pcm_plugin_t *plugin, } } -static void route_to_channel(snd_pcm_plugin_t *plugin, - const snd_pcm_plugin_channel_t *src_channels, - snd_pcm_plugin_channel_t *dst_channel, - ttable_dst_t* ttable, snd_pcm_uframes_t frames) +static void route_to_channel(struct snd_pcm_plugin *plugin, + const struct snd_pcm_plugin_channel *src_channels, + struct snd_pcm_plugin_channel *dst_channel, + struct ttable_dst *ttable, snd_pcm_uframes_t frames) { #define GET_U_LABELS #define PUT_U32_LABELS @@ -153,18 +154,18 @@ static void route_to_channel(snd_pcm_plugin_t *plugin, &&norm_int64_16_att, &&norm_int64_24_att, }; - route_t *data = (route_t *)plugin->extra_data; + struct route_priv *data = (struct route_priv *)plugin->extra_data; void *zero, *get, *add, *norm, *put_u32; int nsrcs = ttable->nsrcs; char *dst; int dst_step; char *srcs[nsrcs]; int src_steps[nsrcs]; - ttable_src_t src_tt[nsrcs]; + struct ttable_src src_tt[nsrcs]; u_int32_t sample = 0; int srcidx, srcidx1 = 0; for (srcidx = 0; srcidx < nsrcs; ++srcidx) { - const snd_pcm_plugin_channel_t *src_channel = &src_channels[ttable->srcs[srcidx].channel]; + const struct snd_pcm_plugin_channel *src_channel = &src_channels[ttable->srcs[srcidx].channel]; if (!src_channel->enabled) continue; srcs[srcidx1] = src_channel->area.addr + src_channel->area.first / 8; @@ -191,8 +192,8 @@ static void route_to_channel(snd_pcm_plugin_t *plugin, dst_step = dst_channel->area.step / 8; while (frames-- > 0) { - ttable_src_t *ttp = src_tt; - sum_t sum; + struct ttable_src *ttp = src_tt; + union sum sum; /* Zero sum */ goto *zero; @@ -297,20 +298,20 @@ static void route_to_channel(snd_pcm_plugin_t *plugin, } } -static int route_src_channels_mask(snd_pcm_plugin_t *plugin, +static int route_src_channels_mask(struct snd_pcm_plugin *plugin, unsigned long *dst_vmask, unsigned long **src_vmask) { - route_t *data = (route_t *)plugin->extra_data; + struct route_priv *data = (struct route_priv *)plugin->extra_data; int schannels = plugin->src_format.channels; int dchannels = plugin->dst_format.channels; unsigned long *vmask = plugin->src_vmask; int channel; - ttable_dst_t *dp = data->ttable; + struct ttable_dst *dp = data->ttable; bitmap_zero(vmask, schannels); for (channel = 0; channel < dchannels; channel++, dp++) { unsigned int src; - ttable_src_t *sp; + struct ttable_src *sp; if (!test_bit(channel, dst_vmask)) continue; sp = dp->srcs; @@ -321,19 +322,19 @@ static int route_src_channels_mask(snd_pcm_plugin_t *plugin, return 0; } -static int route_dst_channels_mask(snd_pcm_plugin_t *plugin, +static int route_dst_channels_mask(struct snd_pcm_plugin *plugin, unsigned long *src_vmask, unsigned long **dst_vmask) { - route_t *data = (route_t *)plugin->extra_data; + struct route_priv *data = (struct route_priv *)plugin->extra_data; int dchannels = plugin->dst_format.channels; unsigned long *vmask = plugin->dst_vmask; int channel; - ttable_dst_t *dp = data->ttable; + struct ttable_dst *dp = data->ttable; bitmap_zero(vmask, dchannels); for (channel = 0; channel < dchannels; channel++, dp++) { unsigned int src; - ttable_src_t *sp; + struct ttable_src *sp; sp = dp->srcs; for (src = 0; src < dp->nsrcs; src++, sp++) { if (test_bit(sp->channel, src_vmask)) { @@ -346,33 +347,33 @@ static int route_dst_channels_mask(snd_pcm_plugin_t *plugin, return 0; } -static void route_free(snd_pcm_plugin_t *plugin) +static void route_free(struct snd_pcm_plugin *plugin) { - route_t *data = (route_t *)plugin->extra_data; + struct route_priv *data = (struct route_priv *)plugin->extra_data; unsigned int dst_channel; for (dst_channel = 0; dst_channel < plugin->dst_format.channels; ++dst_channel) { kfree(data->ttable[dst_channel].srcs); } } -static int route_load_ttable(snd_pcm_plugin_t *plugin, - const route_ttable_entry_t* src_ttable) +static int route_load_ttable(struct snd_pcm_plugin *plugin, + const int *src_ttable) { - route_t *data; + struct route_priv *data; unsigned int src_channel, dst_channel; - const route_ttable_entry_t *sptr; - ttable_dst_t *dptr; + const int *sptr; + struct ttable_dst *dptr; if (src_ttable == NULL) return 0; - data = (route_t *)plugin->extra_data; + data = (struct route_priv *)plugin->extra_data; dptr = data->ttable; sptr = src_ttable; plugin->private_free = route_free; for (dst_channel = 0; dst_channel < plugin->dst_format.channels; ++dst_channel) { - route_ttable_entry_t t = 0; + int t = 0; int att = 0; int nsrcs = 0; - ttable_src_t srcs[plugin->src_format.channels]; + struct ttable_src srcs[plugin->src_format.channels]; for (src_channel = 0; src_channel < plugin->src_format.channels; ++src_channel) { snd_assert(*sptr >= 0 || *sptr <= FULL, return -ENXIO); if (*sptr != 0) { @@ -405,21 +406,21 @@ static int route_load_ttable(snd_pcm_plugin_t *plugin, return 0; } -static snd_pcm_sframes_t route_transfer(snd_pcm_plugin_t *plugin, - const snd_pcm_plugin_channel_t *src_channels, - snd_pcm_plugin_channel_t *dst_channels, +static snd_pcm_sframes_t route_transfer(struct snd_pcm_plugin *plugin, + const struct snd_pcm_plugin_channel *src_channels, + struct snd_pcm_plugin_channel *dst_channels, snd_pcm_uframes_t frames) { - route_t *data; + struct route_priv *data; int src_nchannels, dst_nchannels; int dst_channel; - ttable_dst_t *ttp; - snd_pcm_plugin_channel_t *dvp; + struct ttable_dst *ttp; + struct snd_pcm_plugin_channel *dvp; snd_assert(plugin != NULL && src_channels != NULL && dst_channels != NULL, return -ENXIO); if (frames == 0) return 0; - data = (route_t *)plugin->extra_data; + data = (struct route_priv *)plugin->extra_data; src_nchannels = plugin->src_format.channels; dst_nchannels = plugin->dst_format.channels; @@ -469,14 +470,14 @@ int getput_index(int format) return width * 4 + endian * 2 + sign; } -int snd_pcm_plugin_build_route(snd_pcm_plug_t *plug, - snd_pcm_plugin_format_t *src_format, - snd_pcm_plugin_format_t *dst_format, - route_ttable_entry_t *ttable, - snd_pcm_plugin_t **r_plugin) +int snd_pcm_plugin_build_route(struct snd_pcm_substream *plug, + struct snd_pcm_plugin_format *src_format, + struct snd_pcm_plugin_format *dst_format, + int *ttable, + struct snd_pcm_plugin **r_plugin) { - route_t *data; - snd_pcm_plugin_t *plugin; + struct route_priv *data; + struct snd_pcm_plugin *plugin; int err; snd_assert(r_plugin != NULL, return -ENXIO); @@ -488,12 +489,13 @@ int snd_pcm_plugin_build_route(snd_pcm_plug_t *plug, err = snd_pcm_plugin_build(plug, "attenuated route conversion", src_format, dst_format, - sizeof(route_t) + sizeof(data->ttable[0]) * dst_format->channels, + sizeof(struct route_priv) + + sizeof(data->ttable[0]) * dst_format->channels, &plugin); if (err < 0) return err; - data = (route_t *) plugin->extra_data; + data = (struct route_priv *)plugin->extra_data; data->get = getput_index(src_format->format); snd_assert(data->get >= 0 && data->get < 4*2*2, return -EINVAL); -- cgit v1.2.3-59-g8ed1b