Changed other static checks in assert

diff --git a/src/pcm/pcm.c b/src/pcm/pcm.c
index d7e1661aecf55d3cbb576c239147b664c1fc4a9f..cb0978279dccf58c4b2b011089590f7d3e77c9e5 100644 (file)
--- a/src/pcm/pcm.c
+++ b/src/pcm/pcm.c
@@ -25,7 +25,6 @@
 #include <errno.h>
 #include <sys/poll.h>
 #include <sys/uio.h>
-#include <assert.h>
 #include "pcm_local.h"
 
 int snd_pcm_abstract_open(snd_pcm_t **handle, int mode,
@@ -125,7 +124,7 @@ int snd_pcm_info(snd_pcm_t *pcm, snd_pcm_info_t *info)
                if (pcm->stream[stream].open)
                        return pcm->ops->info(pcm, stream, info);
        }
-       return -EBADFD;
+       assert(0);
 }
 
 int snd_pcm_stream_info(snd_pcm_t *pcm, snd_pcm_stream_info_t *info)
@@ -285,7 +284,7 @@ int snd_pcm_sync_go(snd_pcm_t *pcm, snd_pcm_sync_t *sync)
                if (pcm->stream[stream].open)
                        return pcm->ops->sync_go(pcm, stream, sync);
        }
-       return -EBADFD;
+       assert(0);
 }
 
 int snd_pcm_stream_drain(snd_pcm_t *pcm, int stream)

diff --git a/src/pcm/pcm_common.c b/src/pcm/pcm_common.c
index 414b0866c4d3683acdc78c455ccd280eefc118f4..8c3ce79de503812b91d8383da4addb229d21716f 100644 (file)
--- a/src/pcm/pcm_common.c
+++ b/src/pcm/pcm_common.c
@@ -81,14 +81,12 @@ static ssize_t snd_pcm_plugin_side_channels(snd_pcm_plugin_t *plugin,
        if ((width = snd_pcm_format_physical_width(format->format)) < 0)
                return width;   
        size = format->channels * frames * width;
-       if ((size % 8) != 0)
-               return -EINVAL;
+       assert(size % 8 == 0);
        size /= 8;
        ptr = (char *)snd_pcm_plug_buf_alloc(plugin->handle, plugin->stream, size);
        if (ptr == NULL)
                return -ENOMEM;
-       if ((size % format->channels) != 0)
-               return -EINVAL;
+       assert(size % format->channels == 0);
        size /= format->channels;
        for (channel = 0; channel < format->channels; channel++, v++) {
                v->enabled = 1;
@@ -127,19 +125,14 @@ int snd_pcm_plugin_build(snd_pcm_plugin_handle_t *handle,
                         const char *name,
                         snd_pcm_format_t *src_format,
                         snd_pcm_format_t *dst_format,
-                        int extra,
+                        size_t extra,
                         snd_pcm_plugin_t **ret)
 {
        snd_pcm_plugin_t *plugin;
        
-       if (!handle)
-               return -EFAULT;
-       if (extra < 0)
-               return -EINVAL;
-       if (stream < 0 || stream > 1)
-               return -EINVAL;
-       if (!src_format || !dst_format)
-               return -EFAULT;
+       assert(handle);
+       assert(stream >= 0 && stream <= 1);
+       assert(src_format && dst_format);
        plugin = (snd_pcm_plugin_t *)calloc(1, sizeof(*plugin) + extra);
        if (plugin == NULL)
                return -ENOMEM;
@@ -147,11 +140,11 @@ int snd_pcm_plugin_build(snd_pcm_plugin_handle_t *handle,
        plugin->handle = handle;
        plugin->stream = stream;
        memcpy(&plugin->src_format, src_format, sizeof(snd_pcm_format_t));
-       if ((plugin->src_width = snd_pcm_format_physical_width(src_format->format)) < 0)
-               return -EINVAL;
+       plugin->src_width = snd_pcm_format_physical_width(src_format->format);
+       assert(plugin->src_width > 0);
        memcpy(&plugin->dst_format, dst_format, sizeof(snd_pcm_format_t));
-       if ((plugin->dst_width = snd_pcm_format_physical_width(dst_format->format)) < 0)
-               return -EINVAL;
+       plugin->dst_width = snd_pcm_format_physical_width(dst_format->format);
+       assert(plugin->dst_width > 0);
        plugin->src_channels = calloc(src_format->channels, sizeof(snd_pcm_plugin_channel_t));
        if (plugin->src_channels == NULL) {
                free(plugin);
@@ -205,11 +198,9 @@ ssize_t snd_pcm_plugin_src_frames_to_size(snd_pcm_plugin_t *plugin, size_t frame
 {
        ssize_t result;
 
-       if (plugin == NULL)
-               return -EFAULT;
+       assert(plugin);
        result = frames * plugin->src_format.channels * plugin->src_width;
-       if (result % 8 != 0)
-               return -EINVAL;
+       assert(result % 8 == 0);
        return result / 8;
 }
 
@@ -217,11 +208,9 @@ ssize_t snd_pcm_plugin_dst_frames_to_size(snd_pcm_plugin_t *plugin, size_t frame
 {
        ssize_t result;
 
-       if (plugin == NULL)
-               return -EFAULT;
+       assert(plugin);
        result = frames * plugin->dst_format.channels * plugin->dst_width;
-       if (result % 8 != 0)
-               return -EINVAL;
+       assert(result % 8 == 0);
        return result / 8;
 }
 
@@ -230,12 +219,10 @@ ssize_t snd_pcm_plugin_src_size_to_frames(snd_pcm_plugin_t *plugin, size_t size)
        ssize_t result;
        long tmp;
 
-       if (plugin == NULL)
-               return -EFAULT;
+       assert(plugin);
        result = size * 8;
        tmp = plugin->src_format.channels * plugin->src_width;
-       if (result % tmp != 0)
-               return -EINVAL;
+       assert(result % tmp == 0);
        return result / tmp;
 }
 
@@ -244,12 +231,10 @@ ssize_t snd_pcm_plugin_dst_size_to_frames(snd_pcm_plugin_t *plugin, size_t size)
        ssize_t result;
        long tmp;
 
-       if (plugin == NULL)
-               return -EFAULT;
+       assert(plugin);
        result = size * 8;
        tmp = plugin->dst_format.channels * plugin->dst_width;
-       if (result % tmp != 0)
-               return -EINVAL;
+       assert(result % tmp == 0);
        return result / tmp;
 }
 
@@ -257,11 +242,7 @@ ssize_t snd_pcm_plug_client_frames(snd_pcm_plugin_handle_t *handle, int stream,
 {
        snd_pcm_plugin_t *plugin, *plugin_prev, *plugin_next;
        
-       if (handle == NULL)
-               return -EFAULT;
-       if (stream != SND_PCM_STREAM_PLAYBACK &&
-           stream != SND_PCM_STREAM_CAPTURE)
-               return -EINVAL;
+       assert(handle);
        if (drv_frames == 0)
                return 0;
        if (stream == SND_PCM_STREAM_PLAYBACK) {
@@ -280,7 +261,8 @@ ssize_t snd_pcm_plug_client_frames(snd_pcm_plugin_handle_t *handle, int stream,
                                drv_frames = plugin->dst_frames(plugin, drv_frames);
                        plugin = plugin_next;
                }
-       }
+       } else
+               assert(0);
        return drv_frames;
 }
 
@@ -289,11 +271,7 @@ ssize_t snd_pcm_plug_slave_frames(snd_pcm_plugin_handle_t *handle, int stream, s
        snd_pcm_plugin_t *plugin, *plugin_prev, *plugin_next;
        ssize_t frames;
        
-       if (handle == NULL)
-               return -EFAULT;
-       if (stream != SND_PCM_STREAM_PLAYBACK &&
-           stream != SND_PCM_STREAM_CAPTURE)
-               return -EINVAL;
+       assert(handle);
        if (clt_frames == 0)
                return 0;
        frames = clt_frames;
@@ -319,7 +297,8 @@ ssize_t snd_pcm_plug_slave_frames(snd_pcm_plugin_handle_t *handle, int stream, s
                        }
                        plugin = plugin_prev;
                }
-       } 
+       } else
+               assert(0);
        return frames;
 }
 
@@ -328,11 +307,7 @@ ssize_t snd_pcm_plug_client_size(snd_pcm_plugin_handle_t *handle, int stream, si
        snd_pcm_plugin_t *plugin;
        ssize_t result = 0;
        
-       if (handle == NULL)
-               return -EFAULT;
-       if (stream != SND_PCM_STREAM_PLAYBACK &&
-           stream != SND_PCM_STREAM_CAPTURE)
-               return -EINVAL;
+       assert(handle);
        if (drv_size == 0)
                return 0;
        if (stream == SND_PCM_STREAM_PLAYBACK) {
@@ -359,7 +334,8 @@ ssize_t snd_pcm_plug_client_size(snd_pcm_plugin_handle_t *handle, int stream, si
                        return result;
                plugin = snd_pcm_plug_last(handle, SND_PCM_STREAM_CAPTURE);
                result = snd_pcm_plugin_dst_frames_to_size(plugin, result);
-       }
+       } else
+               assert(0);
        return result;
 }
 
@@ -368,11 +344,7 @@ ssize_t snd_pcm_plug_slave_size(snd_pcm_plugin_handle_t *handle, int stream, siz
        snd_pcm_plugin_t *plugin;
        ssize_t result = 0;
        
-       if (handle == NULL)
-               return -EFAULT;
-       if (stream != SND_PCM_STREAM_PLAYBACK &&
-           stream != SND_PCM_STREAM_CAPTURE)
-               return -EINVAL;
+       assert(handle);
        if (clt_size == 0)
                return 0;
        if (stream == SND_PCM_STREAM_PLAYBACK) {
@@ -399,7 +371,8 @@ ssize_t snd_pcm_plug_slave_size(snd_pcm_plugin_handle_t *handle, int stream, siz
                        return result;
                plugin = snd_pcm_plug_first(handle, SND_PCM_STREAM_CAPTURE);
                result = snd_pcm_plugin_src_frames_to_size(plugin, result);
-       } 
+       } else
+               assert(0);
        return result;
 }
 
@@ -548,6 +521,7 @@ int snd_pcm_plug_format(snd_pcm_plugin_handle_t *handle,
                memcpy(srcparams, slave_params, sizeof(*slave_params));
                break;
        default:
+               assert(0);
                return -EINVAL;
        }
        memcpy(&tmpparams, srcparams, sizeof(*srcparams));
@@ -808,8 +782,7 @@ ssize_t snd_pcm_plug_client_channels_buf(snd_pcm_plugin_handle_t *handle,
        snd_pcm_format_t *format;
        int width, nchannels, channel;
 
-       if (buf == NULL)
-               return -EINVAL;
+       assert(buf);
        if (stream == SND_PCM_STREAM_PLAYBACK) {
                plugin = snd_pcm_plug_first(handle, stream);
                format = &plugin->src_format;
@@ -823,22 +796,18 @@ ssize_t snd_pcm_plug_client_channels_buf(snd_pcm_plugin_handle_t *handle,
        *channels = v;
        if ((width = snd_pcm_format_physical_width(format->format)) < 0)
                return width;
-       if ((count * 8) % width != 0)
-               return -EINVAL;
+       assert(count * 8 % width == 0);
        nchannels = format->channels;
-       if (format->interleave ||
-           format->channels == 1) {
-               for (channel = 0; channel < nchannels; channel++, v++) {
-                       v->enabled = 1;
-                       v->wanted = (stream == SND_PCM_STREAM_CAPTURE);
-                       v->aptr = NULL;
-                       v->area.addr = buf;
-                       v->area.first = channel * width;
-                       v->area.step = nchannels * width;
-               }
-               return count;
-       } else
-               return -EINVAL;
+       assert(format->interleave || format->channels == 1);
+       for (channel = 0; channel < nchannels; channel++, v++) {
+               v->enabled = 1;
+               v->wanted = (stream == SND_PCM_STREAM_CAPTURE);
+               v->aptr = NULL;
+               v->area.addr = buf;
+               v->area.first = channel * width;
+               v->area.step = nchannels * width;
+       }
+       return count;
 }
 
 ssize_t snd_pcm_plug_client_channels_iovec(snd_pcm_plugin_handle_t *handle,
@@ -868,9 +837,8 @@ ssize_t snd_pcm_plug_client_channels_iovec(snd_pcm_plugin_handle_t *handle,
                return width;
        nchannels = format->channels;
        if (format->interleave) {
-               if (count != 1 || vector->iov_base == NULL ||
-                   (vector->iov_len * 8) % width != 0)
-                       return -EINVAL;
+               assert(count == 1 && vector->iov_base &&
+                      vector->iov_len * 8 % width == 0);
                
                for (channel = 0; channel < nchannels; channel++, v++) {
                        v->enabled = 1;
@@ -883,14 +851,11 @@ ssize_t snd_pcm_plug_client_channels_iovec(snd_pcm_plugin_handle_t *handle,
                return vector->iov_len;
        } else {
                size_t len;
-               if (count != nchannels)
-                       return -EINVAL;
+               assert(count == nchannels);
                len = vector->iov_len;
-               if ((len * 8) % width != 0)
-                       return -EINVAL;
+               assert(len * 8 % width == 0);
                for (channel = 0; channel < nchannels; channel++, v++, vector++) {
-                       if (vector->iov_len != len)
-                               return -EINVAL;
+                       assert(vector->iov_len == len);
                        v->enabled = (vector->iov_base != NULL);
                        v->wanted = (v->enabled && (stream == SND_PCM_STREAM_CAPTURE));
                        v->aptr = NULL;
@@ -1234,7 +1199,7 @@ int snd_pcm_area_silence(const snd_pcm_channel_area_t *dst_area, size_t dst_offs
                break;
        }
        default:
-               return -EINVAL;
+               assert(0);
        }
        return 0;
 }
@@ -1370,7 +1335,7 @@ int snd_pcm_area_copy(const snd_pcm_channel_area_t *src_area, size_t src_offset,
                break;
        }
        default:
-               return -EINVAL;
+               assert(0);
        }
        return 0;
 }

diff --git a/src/pcm/pcm_hw.c b/src/pcm/pcm_hw.c
index a69c4226e39b4f4fa1e5d282ab0827e3b0ce0e5c..cda25fb91c9cf3ebd547f3e52a924c872497ce0f 100644 (file)
--- a/src/pcm/pcm_hw.c
+++ b/src/pcm/pcm_hw.c
@@ -54,17 +54,6 @@ static int snd_pcm_hw_stream_close(snd_pcm_t *pcm, int stream)
        return 0;
 }
 
-int snd_pcm_hw_stream_fd(snd_pcm_t *pcm, int stream)
-{
-       snd_pcm_hw_t *hw;
-       if (!pcm)
-               return -EINVAL;
-       if (stream < 0 || stream > 1)
-               return -EINVAL;
-       hw = (snd_pcm_hw_t*) &pcm->private;
-       return hw->stream[stream].fd;
-}
-
 static int snd_pcm_hw_stream_nonblock(snd_pcm_t *pcm, int stream, int nonblock)
 {
        long flags;
@@ -377,7 +366,7 @@ static int snd_pcm_hw_open_stream(int card, int device, int stream, int subdevic
                filefmt = SND_FILE_PCM_CAPTURE;
                break;
        default:
-               return -EINVAL;
+               assert(0);
        }
        if ((err = snd_ctl_pcm_stream_prefer_subdevice(ctl, device, stream, subdevice)) < 0)
                return err;
@@ -424,12 +413,10 @@ int snd_pcm_open_subdevice(snd_pcm_t **handle, int card, int device, int subdevi
        snd_ctl_t *ctl;
        int pfd = -1, cfd = -1;
 
-       if (!handle)
-               return -EFAULT;
+       assert(handle);
        *handle = NULL;
        
-       if (card < 0 || card >= SND_CARDS)
-               return -EINVAL;
+       assert(card >= 0 && card < SND_CARDS);
        if ((err = snd_ctl_open(&ctl, card)) < 0)
                return err;
        if (mode & SND_PCM_OPEN_PLAYBACK) {
@@ -457,8 +444,7 @@ int snd_pcm_open_subdevice(snd_pcm_t **handle, int card, int device, int subdevi
                }
        }
        snd_ctl_close(ctl);
-       if (pfd < 0 && cfd < 0)
-               return -EINVAL;
+       assert(pfd >= 0 || cfd >= 0);
 
        err = snd_pcm_abstract_open(handle, mode, SND_PCM_TYPE_HW, sizeof(snd_pcm_hw_t));
        if (err < 0) {

diff --git a/src/pcm/pcm_local.h b/src/pcm/pcm_local.h
index cb6c0d4aeca797895c32409a21d36f75b0dcf9ee..76cda9fad45151fe56bbe9d3e2344713acc449b1 100644 (file)
--- a/src/pcm/pcm_local.h
+++ b/src/pcm/pcm_local.h
@@ -19,7 +19,7 @@
  *
  */
 
-#include <pthread.h>
+#include <assert.h>
 #include "asoundlib.h"
   
 struct snd_pcm_ops {

diff --git a/src/pcm/pcm_mmap.c b/src/pcm/pcm_mmap.c
index 77a4d4e26c45b6fb6b70a58b46680d6f9a62d726..0f8af94d0525cec4b127b401bac159a6d08b7fb1 100644 (file)
--- a/src/pcm/pcm_mmap.c
+++ b/src/pcm/pcm_mmap.c
@@ -21,7 +21,6 @@
 #include <stdio.h>
 #include <malloc.h>
 #include <errno.h>
-#include <assert.h>
 #include <sys/poll.h>
 #include <sys/uio.h>
 #include "pcm_local.h"
@@ -43,13 +42,10 @@ static size_t snd_pcm_mmap_capture_frames_avail(snd_pcm_t *pcm)
 int snd_pcm_frames_avail(snd_pcm_t *pcm, int stream, ssize_t *frames)
 {
        snd_pcm_stream_t *str;
-        if (!pcm)
-                return -EFAULT;
-        if (stream < 0 || stream > 1)
-                return -EINVAL;
+        assert(pcm);
+        assert(stream >= 0 && stream <= 1);
        str = &pcm->stream[stream];
-       if (!str->mmap_control)
-               return -EBADFD;
+       assert(str->mmap_control);
        if (stream == SND_PCM_STREAM_PLAYBACK)
                *frames = snd_pcm_mmap_playback_frames_avail(pcm);
        else
@@ -85,16 +81,12 @@ int snd_pcm_mmap_ready(snd_pcm_t *pcm, int stream)
 {
        snd_pcm_stream_t *str;
        snd_pcm_mmap_control_t *ctrl;
-        if (!pcm)
-                return -EFAULT;
-        if (stream < 0 || stream > 1)
-                return -EINVAL;
+        assert(pcm);
+        assert(stream >= 0 && stream <= 1);
        str = &pcm->stream[stream];
-       if (!str->mmap_control)
-               return -EBADFD;
        ctrl = str->mmap_control;
-       if (ctrl->status < SND_PCM_STATUS_PREPARED)
-               return -EBADFD;
+       assert(ctrl);
+       assert(ctrl->status >= SND_PCM_STATUS_PREPARED);
        if (stream == SND_PCM_STREAM_PLAYBACK) {
                return snd_pcm_mmap_playback_ready(pcm);
        } else {
@@ -149,13 +141,10 @@ static ssize_t snd_pcm_mmap_capture_frames_xfer(snd_pcm_t *pcm, size_t frames)
 ssize_t snd_pcm_mmap_frames_xfer(snd_pcm_t *pcm, int stream, size_t frames)
 {
        snd_pcm_stream_t *str;
-        if (!pcm)
-                return -EFAULT;
-        if (stream < 0 || stream > 1)
-                return -EINVAL;
+        assert(pcm);
+        assert(stream >= 0 && stream <= 1);
        str = &pcm->stream[stream];
-       if (!str->mmap_control)
-               return -EBADFD;
+       assert(str->mmap_control);
        if (stream == SND_PCM_STREAM_PLAYBACK)
                return snd_pcm_mmap_playback_frames_xfer(pcm, frames);
        else
@@ -166,16 +155,11 @@ ssize_t snd_pcm_mmap_frames_offset(snd_pcm_t *pcm, int stream)
 {
        snd_pcm_stream_t *str;
        snd_pcm_mmap_control_t *ctrl;
-        if (!pcm)
-                return -EFAULT;
-        if (stream < 0 || stream > 1)
-                return -EINVAL;
+        assert(pcm);
+        assert(stream >= 0 && stream <= 1);
        str = &pcm->stream[stream];
-       if (!str->mmap_control)
-               return -EBADFD;
        ctrl = str->mmap_control;
-       if (!ctrl)
-               return -EBADFD;
+       assert(ctrl);
        return (ctrl->byte_data % str->setup.buffer_size) * 8 / str->bits_per_frame;
 }
 
@@ -265,11 +249,9 @@ ssize_t snd_pcm_mmap_write_areas(snd_pcm_t *pcm, snd_pcm_channel_area_t *channel
 
        str = &pcm->stream[SND_PCM_STREAM_PLAYBACK];
        ctrl = str->mmap_control;
-       if (ctrl->status < SND_PCM_STATUS_PREPARED)
-               return -EBADFD;
+       assert(ctrl->status >= SND_PCM_STATUS_PREPARED);
        if (str->setup.mode == SND_PCM_MODE_FRAGMENT) {
-               if (frames % str->frames_per_frag != 0)
-                       return -EINVAL;
+               assert(frames % str->frames_per_frag == 0);
        } else {
                if (ctrl->status == SND_PCM_STATUS_RUNNING &&
                    str->mode & SND_PCM_NONBLOCK)
@@ -322,16 +304,12 @@ ssize_t snd_pcm_mmap_write_frames(snd_pcm_t *pcm, const void *buffer, size_t fra
 {
        snd_pcm_stream_t *str;
        unsigned int nchannels;
-       if (!pcm)
-               return -EFAULT;
+       assert(pcm);
        str = &pcm->stream[SND_PCM_STREAM_PLAYBACK];
-       if (!str->mmap_data || !str->mmap_control)
-               return -EBADFD;
-       if (frames > 0 && !buffer)
-               return -EFAULT;
+       assert(str->mmap_data && str->mmap_control);
+       assert(frames == 0 || buffer);
        nchannels = str->setup.format.channels;
-       if (!str->setup.format.interleave && nchannels > 1)
-               return -EINVAL;
+       assert(str->setup.format.interleave || nchannels == 1);
        {
                snd_pcm_channel_area_t channels[nchannels];
                unsigned int channel;
@@ -349,16 +327,12 @@ ssize_t snd_pcm_mmap_write(snd_pcm_t *pcm, const void *buffer, size_t bytes)
        snd_pcm_stream_t *str;
        unsigned int nchannels;
        ssize_t frames;
-       if (!pcm)
-               return -EFAULT;
+       assert(pcm);
        str = &pcm->stream[SND_PCM_STREAM_PLAYBACK];
-       if (!str->mmap_data || !str->mmap_control)
-               return -EBADFD;
-       if (bytes > 0 && !buffer)
-               return -EFAULT;
+       assert(str->mmap_data && str->mmap_control);
+       assert(bytes == 0 || buffer);
        nchannels = str->setup.format.channels;
-       if (!str->setup.format.interleave && nchannels > 1)
-               return -EINVAL;
+       assert(str->setup.format.interleave || nchannels == 1);
        frames = bytes * 8 / str->bits_per_frame;
        frames = snd_pcm_mmap_write_frames(pcm, buffer, frames);
        if (frames <= 0)
@@ -371,13 +345,10 @@ ssize_t snd_pcm_mmap_writev(snd_pcm_t *pcm, const struct iovec *vector, unsigned
        snd_pcm_stream_t *str;
        size_t result = 0;
        unsigned int nchannels;
-       if (!pcm)
-               return -EFAULT;
+       assert(pcm);
        str = &pcm->stream[SND_PCM_STREAM_PLAYBACK];
-       if (!str->mmap_data || !str->mmap_control)
-               return -EBADFD;
-       if (vcount > 0 && !vector)
-               return -EFAULT;
+       assert(str->mmap_data && str->mmap_control);
+       assert(vcount == 0 || vector);
        nchannels = str->setup.format.channels;
        if (str->setup.format.interleave) {
                unsigned int b;
@@ -396,8 +367,7 @@ ssize_t snd_pcm_mmap_writev(snd_pcm_t *pcm, const struct iovec *vector, unsigned
                snd_pcm_channel_area_t channels[nchannels];
                unsigned long bcount;
                unsigned int b;
-               if (vcount % nchannels)
-                       return -EINVAL;
+               assert(vcount % nchannels == 0);
                bcount = vcount / nchannels;
                for (b = 0; b < bcount; b++) {
                        unsigned int v;
@@ -406,8 +376,7 @@ ssize_t snd_pcm_mmap_writev(snd_pcm_t *pcm, const struct iovec *vector, unsigned
                        size_t frames;
                        bytes = vector[0].iov_len;
                        for (v = 0; v < nchannels; ++v) {
-                               if (vector[v].iov_len != bytes)
-                                       return -EINVAL;
+                               assert(vector[v].iov_len == bytes);
                                channels[v].addr = vector[v].iov_base;
                                channels[v].first = 0;
                                channels[v].step = str->sample_width;
@@ -438,11 +407,9 @@ ssize_t snd_pcm_mmap_read_areas(snd_pcm_t *pcm, snd_pcm_channel_area_t *channels
 
        str = &pcm->stream[SND_PCM_STREAM_CAPTURE];
        ctrl = str->mmap_control;
-       if (ctrl->status < SND_PCM_STATUS_PREPARED)
-               return -EBADFD;
+       assert(ctrl->status >= SND_PCM_STATUS_PREPARED);
        if (str->setup.mode == SND_PCM_MODE_FRAGMENT) {
-               if (frames % str->frames_per_frag != 0)
-                       return -EINVAL;
+               assert(frames % str->frames_per_frag == 0);
        } else {
                if (ctrl->status == SND_PCM_STATUS_RUNNING &&
                    str->mode & SND_PCM_NONBLOCK)
@@ -494,16 +461,12 @@ ssize_t snd_pcm_mmap_read_frames(snd_pcm_t *pcm, const void *buffer, size_t fram
 {
        snd_pcm_stream_t *str;
        unsigned int nchannels;
-       if (!pcm)
-               return -EFAULT;
+       assert(pcm);
        str = &pcm->stream[SND_PCM_STREAM_CAPTURE];
-       if (!str->mmap_data || !str->mmap_control)
-               return -EBADFD;
-       if (frames > 0 && !buffer)
-               return -EFAULT;
+       assert(str->mmap_data && str->mmap_control);
+       assert(frames == 0 || buffer);
        nchannels = str->setup.format.channels;
-       if (!str->setup.format.interleave && nchannels > 1)
-               return -EINVAL;
+       assert(str->setup.format.interleave || nchannels == 1);
        {
                snd_pcm_channel_area_t channels[nchannels];
                unsigned int channel;
@@ -521,16 +484,12 @@ ssize_t snd_pcm_mmap_read(snd_pcm_t *pcm, void *buffer, size_t bytes)
        snd_pcm_stream_t *str;
        unsigned int nchannels;
        ssize_t frames;
-       if (!pcm)
-               return -EFAULT;
+       assert(pcm);
        str = &pcm->stream[SND_PCM_STREAM_CAPTURE];
-       if (!str->mmap_data || !str->mmap_control)
-               return -EBADFD;
-       if (bytes > 0 && !buffer)
-               return -EFAULT;
+       assert(str->mmap_data && str->mmap_control);
+       assert(bytes == 0 || buffer);
        nchannels = str->setup.format.channels;
-       if (!str->setup.format.interleave && nchannels > 1)
-               return -EINVAL;
+       assert(str->setup.format.interleave || nchannels == 1);
        frames = bytes * 8 / str->bits_per_frame;
        frames = snd_pcm_mmap_read_frames(pcm, buffer, frames);
        if (frames <= 0)
@@ -543,13 +502,10 @@ ssize_t snd_pcm_mmap_readv(snd_pcm_t *pcm, const struct iovec *vector, unsigned
        snd_pcm_stream_t *str;
        size_t result = 0;
        unsigned int nchannels;
-       if (!pcm)
-               return -EFAULT;
+       assert(pcm);
        str = &pcm->stream[SND_PCM_STREAM_CAPTURE];
-       if (!str->mmap_data || !str->mmap_control)
-               return -EBADFD;
-       if (vcount > 0 && !vector)
-               return -EFAULT;
+       assert(str->mmap_data && str->mmap_control);
+       assert(vcount == 0 || vector);
        nchannels = str->setup.format.channels;
        if (str->setup.format.interleave) {
                unsigned int b;
@@ -568,8 +524,7 @@ ssize_t snd_pcm_mmap_readv(snd_pcm_t *pcm, const struct iovec *vector, unsigned
                snd_pcm_channel_area_t channels[nchannels];
                unsigned long bcount;
                unsigned int b;
-               if (vcount % nchannels)
-                       return -EINVAL;
+               assert(vcount % nchannels == 0);
                bcount = vcount / nchannels;
                for (b = 0; b < bcount; b++) {
                        unsigned int v;
@@ -578,8 +533,7 @@ ssize_t snd_pcm_mmap_readv(snd_pcm_t *pcm, const struct iovec *vector, unsigned
                        size_t frames;
                        bytes = vector[0].iov_len;
                        for (v = 0; v < nchannels; ++v) {
-                               if (vector[v].iov_len != bytes)
-                                       return -EINVAL;
+                               assert(vector[v].iov_len == bytes);
                                channels[v].addr = vector[v].iov_base;
                                channels[v].first = 0;
                                channels[v].step = str->sample_width;
@@ -605,22 +559,21 @@ int snd_pcm_mmap_control(snd_pcm_t *pcm, int stream, snd_pcm_mmap_control_t **co
        snd_pcm_stream_t *str;
        size_t csize;
        int err;
-       if (!pcm || !control)
-               return -EFAULT;
-       if (stream < 0 || stream > 1)
-               return -EINVAL;
+       assert(pcm);
+       assert(stream >= 0 && stream <= 1);
        str = &pcm->stream[stream];
-       if (!str->valid_setup)
-               return -EBADFD;
+       assert(str->valid_setup);
        if (str->mmap_control) {
-               *control = str->mmap_control;
+               if (control)
+                       *control = str->mmap_control;
                return 0;
        }
        csize = sizeof(snd_pcm_mmap_control_t);
 
-       if ((err = pcm->ops->mmap_control(pcm, stream, control, csize)) < 0)
+       if ((err = pcm->ops->mmap_control(pcm, stream, &str->mmap_control, csize)) < 0)
                return err;
-       str->mmap_control = *control;
+       if (control)
+               *control = str->mmap_control;
        str->mmap_control_size = csize;
        return 0;
 }
@@ -633,13 +586,10 @@ int snd_pcm_mmap_get_areas(snd_pcm_t *pcm, int stream, snd_pcm_channel_area_t *a
        unsigned int channel;
        int interleaved = 1, noninterleaved = 1;
        int err;
-       if (!pcm)
-               return -EFAULT;
-       if (stream < 0 || stream > 1)
-               return -EINVAL;
+       assert(pcm);
+       assert(stream >= 0 && stream <= 1);
        str = &pcm->stream[stream];
-       if (!str->mmap_data)
-               return -EBADFD;
+       assert(str->mmap_data);
        a = calloc(str->setup.format.channels, sizeof(*areas));
        for (channel = 0, ap = a; channel < str->setup.format.channels; ++channel, ++ap) {
                s.channel = channel;
@@ -674,15 +624,13 @@ int snd_pcm_mmap_data(snd_pcm_t *pcm, int stream, void **data)
        snd_pcm_stream_info_t info;
        size_t bsize;
        int err;
-       if (!pcm || !data)
-               return -EFAULT;
-       if (stream < 0 || stream > 1)
-               return -EINVAL;
+       assert(pcm);
+       assert(stream >= 0 && stream <= 1);
        str = &pcm->stream[stream];
-       if (!str->valid_setup)
-               return -EBADFD;
+       assert(str->valid_setup);
        if (str->mmap_data) {
-               *data = str->mmap_data;
+               if (data)
+                       *data = str->mmap_data;
                return 0;
        }
 
@@ -693,9 +641,10 @@ int snd_pcm_mmap_data(snd_pcm_t *pcm, int stream, void **data)
        bsize = info.mmap_size;
        if (!(info.flags & SND_PCM_STREAM_INFO_MMAP))
                return -ENXIO;
-       if ((err = pcm->ops->mmap_data(pcm, stream, data, bsize)) < 0)
+       if ((err = pcm->ops->mmap_data(pcm, stream, (void**)&str->mmap_data, bsize)) < 0)
                return err;
-       str->mmap_data = *data;
+       if (data) 
+               *data = str->mmap_data;
        str->mmap_data_size = bsize;
        err = snd_pcm_mmap_get_areas(pcm, stream, NULL);
        if (err < 0)
@@ -721,13 +670,10 @@ int snd_pcm_munmap_control(snd_pcm_t *pcm, int stream)
 {
        int err;
        snd_pcm_stream_t *str;
-       if (!pcm)
-               return -EFAULT;
-       if (stream < 0 || stream > 1)
-               return -EINVAL;
+       assert(pcm);
+       assert(stream >= 0 && stream <= 1);
        str = &pcm->stream[stream];
-       if (!str->mmap_control)
-               return -EBADFD;
+       assert(str->mmap_control);
        if ((err = pcm->ops->munmap_control(pcm, stream, str->mmap_control, str->mmap_control_size)) < 0)
                return err;
        str->mmap_control = 0;
@@ -739,13 +685,10 @@ int snd_pcm_munmap_data(snd_pcm_t *pcm, int stream)
 {
        int err;
        snd_pcm_stream_t *str;
-       if (!pcm)
-               return -EFAULT;
-       if (stream < 0 || stream > 1)
-               return -EINVAL;
+       assert(pcm);
+       assert(stream >= 0 && stream <= 1);
        str = &pcm->stream[stream];
-       if (!str->mmap_data)
-               return -EBADFD;
+       assert(str->mmap_data);
        if ((err = pcm->ops->munmap_data(pcm, stream, str->mmap_data, str->mmap_data_size)) < 0)
                return err;
        free(str->channels);

diff --git a/src/pcm/pcm_plug.c b/src/pcm/pcm_plug.c
index 505f938e8bef7451e1668f4a59ad89148a831dd9..0507bb1d7ee594ec06d7b2eecf1faeee6c6e050f 100644 (file)
--- a/src/pcm/pcm_plug.c
+++ b/src/pcm/pcm_plug.c
@@ -86,8 +86,7 @@ int snd_pcm_plugin_insert(snd_pcm_plugin_t *plugin)
        snd_pcm_plug_t *plug;
        snd_pcm_plug_stream_t *plugstr;
        snd_pcm_t *pcm;
-       if (!plugin)
-               return -EFAULT;
+       assert(plugin);
        pcm = plugin->handle;
        plug = (snd_pcm_plug_t*) &pcm->private;
        plugstr = &plug->stream[plugin->stream];
@@ -108,8 +107,7 @@ int snd_pcm_plugin_append(snd_pcm_plugin_t *plugin)
        snd_pcm_plug_t *plug;
        snd_pcm_plug_stream_t *plugstr;
        snd_pcm_t *pcm;
-       if (!plugin)
-               return -EFAULT;
+       assert(plugin);
        pcm = plugin->handle;
        plug = (snd_pcm_plug_t*) &pcm->private;
        plugstr = &plug->stream[plugin->stream];
@@ -133,8 +131,7 @@ int snd_pcm_plugin_remove_to(snd_pcm_plugin_t *plugin)
        snd_pcm_plug_t *plug;
        snd_pcm_t *pcm;
        snd_pcm_plug_stream_t *plugstr;
-       if (!plugin)
-               return -EFAULT;
+       assert(plugin);
        pcm = plugin->handle;
 
        plug = (snd_pcm_plug_t*) &pcm->private;
@@ -161,12 +158,9 @@ int snd_pcm_plug_remove_first(snd_pcm_t *pcm, int stream)
        snd_pcm_plugin_t *plugin;
        snd_pcm_plug_t *plug;
        snd_pcm_plug_stream_t *plugstr;
-       if (!pcm)
-               return -EFAULT;
-       if (stream < 0 || stream > 1)
-               return -EINVAL;
-       if (!pcm->stream[stream].open)
-               return -EBADFD;
+       assert(pcm);
+       assert(stream >= 0 && stream <= 1);
+       assert(pcm->stream[stream].open);
 
        plug = (snd_pcm_plug_t*) &pcm->private;
        plugstr = &plug->stream[stream];
@@ -190,12 +184,9 @@ int snd_pcm_plug_clear(snd_pcm_t *pcm, int stream)
        snd_pcm_plug_stream_t *plugstr;
        int idx;
        
-       if (!pcm)
-               return -EINVAL;
-       if (stream < 0 || stream > 1)
-               return -EINVAL;
-       if (!pcm->stream[stream].open)
-               return -EBADFD;
+       assert(pcm);
+       assert(stream >= 0 && stream <= 1);
+       assert(pcm->stream[stream].open);
 
        plug = (snd_pcm_plug_t*) &pcm->private;
        plugstr = &plug->stream[stream];
@@ -257,40 +248,6 @@ int snd_pcm_plug_direct(snd_pcm_t *pcm, int stream)
        return snd_pcm_plug_first(pcm, stream) == NULL;
 }
 
-#if 0
-double snd_pcm_plug_client_ratio(snd_pcm_t *pcm, int stream)
-{
-       ssize_t client;
-       if (!pcm)
-               return -EFAULT;
-       if (stream < 0 || stream > 1)
-               return -EINVAL;
-       if (!pcm->stream[stream].open)
-               return -EBADFD;
-
-       client = snd_pcm_plug_client_size(pcm, stream, 1000000);
-       if (client < 0)
-               return 0;
-       return (double)client / (double)1000000;
-}
-
-double snd_pcm_plug_slave_ratio(snd_pcm_t *pcm, int stream)
-{
-       ssize_t slave;
-       if (!pcm)
-               return -EFAULT;
-       if (stream < 0 || stream > 1)
-               return -EINVAL;
-       if (!pcm->stream[stream].open)
-               return -EBADFD;
-
-       slave = snd_pcm_plug_slave_size(pcm, stream, 1000000);
-       if (slave < 0)
-               return 0;
-       return (double)slave / (double)1000000;
-}
-#endif
-
 /*
  *
  */
@@ -377,6 +334,7 @@ static int snd_pcm_plug_stream_params(snd_pcm_t *pcm, snd_pcm_stream_params_t *p
        snd_pcm_stream_info_t slave_info;
        snd_pcm_plugin_t *plugin;
        snd_pcm_plug_t *plug;
+       size_t bytes_per_frame;
        int err;
        int stream = params->stream;
        
@@ -408,12 +366,21 @@ static int snd_pcm_plug_stream_params(snd_pcm_t *pcm, snd_pcm_stream_params_t *p
                return snd_pcm_stream_params(plug->slave, params);
 
        /* compute right sizes */
-       slave_params.frag_size = snd_pcm_plug_slave_size(pcm, stream, params->frag_size);
-       slave_params.buffer_size = snd_pcm_plug_slave_size(pcm, stream, params->buffer_size);
-       slave_params.bytes_fill_max = snd_pcm_plug_slave_size(pcm, stream, params->bytes_fill_max);
-       slave_params.bytes_min = snd_pcm_plug_slave_size(pcm, stream, params->bytes_min);
-       slave_params.bytes_xrun_max = snd_pcm_plug_slave_size(pcm, stream, params->bytes_xrun_max);
-       slave_params.bytes_align = snd_pcm_plug_slave_size(pcm, stream, params->bytes_align);
+       bytes_per_frame = snd_pcm_format_size(params->format.format, params->format.channels);
+       if (bytes_per_frame == 0)
+               bytes_per_frame = 1;
+       params1.frag_size -= params1.frag_size % bytes_per_frame;
+       slave_params.frag_size = snd_pcm_plug_slave_size(pcm, stream, params1.frag_size);
+       params1.buffer_size -= params1.buffer_size % bytes_per_frame;
+       slave_params.buffer_size = snd_pcm_plug_slave_size(pcm, stream, params1.buffer_size);
+       params1.bytes_fill_max -= params1.bytes_fill_max % bytes_per_frame;
+       slave_params.bytes_fill_max = snd_pcm_plug_slave_size(pcm, stream, params1.bytes_fill_max);
+       params1.bytes_min -= params1.bytes_min % bytes_per_frame;
+       slave_params.bytes_min = snd_pcm_plug_slave_size(pcm, stream, params1.bytes_min);
+       params1.bytes_xrun_max -= params1.bytes_xrun_max % bytes_per_frame;
+       slave_params.bytes_xrun_max = snd_pcm_plug_slave_size(pcm, stream, params1.bytes_xrun_max);
+       params1.bytes_align -= params1.bytes_align % bytes_per_frame;
+       slave_params.bytes_align = snd_pcm_plug_slave_size(pcm, stream, params1.bytes_align);
        if (slave_params.byte_boundary == 0 || slave_params.byte_boundary > INT_MAX)
                slave_params.byte_boundary = INT_MAX;
        slave_params.byte_boundary /= params->buffer_size;
@@ -625,8 +592,7 @@ ssize_t snd_pcm_plug_writev(snd_pcm_t *pcm, const struct iovec *vector, unsigned
                step = 1;
        else {
                step = channels;
-               if (count % channels != 0)
-                       return -EINVAL;
+               assert(count % channels == 0);
        }
        for (k = 0; k < count; k += step, vector += step) {
                snd_pcm_plugin_channel_t *channels;
@@ -660,8 +626,7 @@ ssize_t snd_pcm_plug_readv(snd_pcm_t *pcm, const struct iovec *vector, unsigned
                step = 1;
        else {
                step = channels;
-               if (count % channels != 0)
-                       return -EINVAL;
+               assert(count % channels == 0);
        }
        for (k = 0; k < count; k += step) {
                snd_pcm_plugin_channel_t *channels;

diff --git a/src/pcm/plugin/adpcm.c b/src/pcm/plugin/adpcm.c
index 7cedfa45b3aefa94acc0208e5983e3d0123f6b47..13cb76d162c71e707cf0dde09e4f44a95667a68f 100644 (file)
--- a/src/pcm/plugin/adpcm.c
+++ b/src/pcm/plugin/adpcm.c
@@ -333,23 +333,20 @@ static ssize_t adpcm_transfer(snd_pcm_plugin_t *plugin,
        adpcm_t *data;
        unsigned int channel;
 
-       if (plugin == NULL || src_channels == NULL || dst_channels == NULL)
-               return -EFAULT;
+       assert(plugin && src_channels && dst_channels);
        if (frames == 0)
                return 0;
        for (channel = 0; channel < plugin->src_format.channels; channel++) {
                if (plugin->src_format.format == SND_PCM_SFMT_IMA_ADPCM) {
-                       if (src_channels[channel].area.first % 4 != 0 ||
-                           src_channels[channel].area.step % 4 != 0 ||
-                           dst_channels[channel].area.first % 8 != 0 ||
-                           dst_channels[channel].area.step % 8 != 0)
-                               return -EINVAL;
+                       assert(src_channels[channel].area.first % 4 == 0 &&
+                              src_channels[channel].area.step % 4 == 0 &&
+                              dst_channels[channel].area.first % 8 == 0 &&
+                              dst_channels[channel].area.step % 8 == 0);
                } else {
-                       if (src_channels[channel].area.first % 8 != 0 ||
-                           src_channels[channel].area.step % 8 != 0 ||
-                           dst_channels[channel].area.first % 4 != 0 ||
-                           dst_channels[channel].area.step % 4 != 0)
-                               return -EINVAL;
+                       assert(src_channels[channel].area.first % 8 == 0 &&
+                              src_channels[channel].area.step % 8 == 0 &&
+                              dst_channels[channel].area.first % 4 == 0 &&
+                              dst_channels[channel].area.step % 4 == 0);
                }
        }
        data = (adpcm_t *)plugin->extra_data;
@@ -361,8 +358,7 @@ static int adpcm_action(snd_pcm_plugin_t * plugin,
                        snd_pcm_plugin_action_t action,
                        unsigned long udata UNUSED)
 {
-       if (plugin == NULL)
-               return -EINVAL;
+       assert(plugin);
        switch (action) {
        case INIT:
        case PREPARE:
@@ -388,14 +384,11 @@ int snd_pcm_plugin_build_adpcm(snd_pcm_plugin_handle_t *handle,
        snd_pcm_format_t *format;
        adpcm_f func;
 
-       if (r_plugin == NULL)
-               return -EINVAL;
+       assert(r_plugin);
        *r_plugin = NULL;
 
-       if (src_format->rate != dst_format->rate)
-               return -EINVAL;
-       if (src_format->channels != dst_format->channels)
-               return -EINVAL;
+       assert(src_format->rate == dst_format->rate);
+       assert(src_format->channels == dst_format->channels);
 
        if (dst_format->format == SND_PCM_SFMT_IMA_ADPCM) {
                format = src_format;
@@ -406,9 +399,8 @@ int snd_pcm_plugin_build_adpcm(snd_pcm_plugin_handle_t *handle,
                func = adpcm_decode;
        }
        else
-               return -EINVAL;
-       if (!snd_pcm_format_linear(format->format))
-               return -EINVAL;
+               assert(0);
+       assert(snd_pcm_format_linear(format->format));
 
        err = snd_pcm_plugin_build(handle, stream,
                                   "Ima-ADPCM<->linear conversion",

diff --git a/src/pcm/plugin/alaw.c b/src/pcm/plugin/alaw.c
index 0335ea31c39b3778cc642da86f7082d1038f2d06..5357c207111801caf2e29fda2980b7e1d315da67 100644 (file)
--- a/src/pcm/plugin/alaw.c
+++ b/src/pcm/plugin/alaw.c
@@ -234,17 +234,14 @@ static ssize_t alaw_transfer(snd_pcm_plugin_t *plugin,
        alaw_t *data;
        unsigned int channel;
 
-       if (plugin == NULL || src_channels == NULL || dst_channels == NULL)
-               return -EFAULT;
+       assert(plugin && src_channels && dst_channels);
        if (frames == 0)
                return 0;
        for (channel = 0; channel < plugin->src_format.channels; channel++) {
-               if (src_channels[channel].area.first % 8 != 0 || 
-                   src_channels[channel].area.step % 8 != 0)
-                       return -EINVAL;
-               if (dst_channels[channel].area.first % 8 != 0 || 
-                   dst_channels[channel].area.step % 8 != 0)
-                       return -EINVAL;
+               assert(src_channels[channel].area.first % 8 == 0 && 
+                      src_channels[channel].area.step % 8 == 0);
+               assert(dst_channels[channel].area.first % 8 == 0 &&
+                      dst_channels[channel].area.step % 8 == 0);
        }
        data = (alaw_t *)plugin->extra_data;
        data->func(plugin, src_channels, dst_channels, frames);
@@ -263,14 +260,11 @@ int snd_pcm_plugin_build_alaw(snd_pcm_plugin_handle_t *handle,
        snd_pcm_format_t *format;
        alaw_f func;
 
-       if (r_plugin == NULL)
-               return -EINVAL;
+       assert(r_plugin);
        *r_plugin = NULL;
 
-       if (src_format->rate != dst_format->rate)
-               return -EINVAL;
-       if (src_format->channels != dst_format->channels)
-               return -EINVAL;
+       assert(src_format->rate == dst_format->rate);
+       assert(src_format->channels == dst_format->channels);
 
        if (dst_format->format == SND_PCM_SFMT_A_LAW) {
                format = src_format;
@@ -281,9 +275,8 @@ int snd_pcm_plugin_build_alaw(snd_pcm_plugin_handle_t *handle,
                func = alaw_decode;
        }
        else
-               return -EINVAL;
-       if (!snd_pcm_format_linear(format->format))
-               return -EINVAL;
+               assert(0);
+       assert(snd_pcm_format_linear(format->format));
 
        err = snd_pcm_plugin_build(handle, stream,
                                   "A-Law<->linear conversion",

diff --git a/src/pcm/plugin/copy.c b/src/pcm/plugin/copy.c
index f009ee5c6bcd112f3ffd2fe5571fddec883cadfc..63ef714b7a42c02bea6a70d7fd0452c1f9ae271d 100644 (file)
--- a/src/pcm/plugin/copy.c
+++ b/src/pcm/plugin/copy.c
@@ -42,18 +42,15 @@ static ssize_t copy_transfer(snd_pcm_plugin_t *plugin,
        unsigned int channel;
        unsigned int nchannels;
 
-       if (plugin == NULL || src_channels == NULL || dst_channels == NULL)
-               return -EFAULT;
+       assert(plugin && src_channels && dst_channels);
        if (frames == 0)
                return 0;
        nchannels = plugin->src_format.channels;
        for (channel = 0; channel < nchannels; channel++) {
-               if (src_channels->area.first % 8 != 0 || 
-                   src_channels->area.step % 8 != 0)
-                       return -EINVAL;
-               if (dst_channels->area.first % 8 != 0 || 
-                   dst_channels->area.step % 8 != 0)
-                       return -EINVAL;
+               assert(src_channels->area.first % 8 == 0 &&
+                      src_channels->area.step % 8 == 0);
+               assert(dst_channels->area.first % 8 == 0 &&
+                      dst_channels->area.step % 8 == 0);
                if (!src_channels->enabled) {
                        if (dst_channels->wanted)
                                snd_pcm_area_silence(&dst_channels->area, 0, frames, plugin->dst_format.format);
@@ -78,20 +75,15 @@ int snd_pcm_plugin_build_copy(snd_pcm_plugin_handle_t *handle,
        snd_pcm_plugin_t *plugin;
        int width;
 
-       if (r_plugin == NULL)
-               return -EFAULT;
+       assert(r_plugin);
        *r_plugin = NULL;
 
-       if (src_format->format != dst_format->format)
-               return -EINVAL;
-       if (src_format->rate != dst_format->rate)
-               return -EINVAL;
-       if (src_format->channels != dst_format->channels)
-               return -EINVAL;
+       assert(src_format->format == dst_format->format);
+       assert(src_format->rate == dst_format->rate);
+       assert(src_format->channels == dst_format->channels);
 
        width = snd_pcm_format_physical_width(src_format->format);
-       if (width < 0)
-               return -EINVAL;
+       assert(width > 0);
 
        err = snd_pcm_plugin_build(handle, stream,
                                   "copy",

diff --git a/src/pcm/plugin/io.c b/src/pcm/plugin/io.c
index f4561f6f4cdc034bc34f49394c01492c7a88cf31..afdd5732e1eb83455495812e5f84e3ca2abced19 100644 (file)
--- a/src/pcm/plugin/io.c
+++ b/src/pcm/plugin/io.c
@@ -55,15 +55,12 @@ static ssize_t io_transfer(snd_pcm_plugin_t *plugin,
        struct iovec *vec;
        int count, channel;
 
-       if (plugin == NULL)
-               return -EINVAL;
+       assert(plugin);
        data = (io_t *)plugin->extra_data;
-       if (data == NULL)
-               return -EINVAL;
+       assert(data);
        vec = (struct iovec *)((char *)data + sizeof(*data));
        if (plugin->stream == SND_PCM_STREAM_PLAYBACK) {
-               if (src_channels == NULL)
-                       return -EINVAL;
+               assert(src_channels);
                if ((result = snd_pcm_plugin_src_frames_to_size(plugin, frames)) < 0)
                        return result;
                count = plugin->src_format.channels;
@@ -84,8 +81,7 @@ static ssize_t io_transfer(snd_pcm_plugin_t *plugin,
                        return result;
                return snd_pcm_plugin_src_size_to_frames(plugin, result);
        } else if (plugin->stream == SND_PCM_STREAM_CAPTURE) {
-               if (dst_channels == NULL)
-                       return -EINVAL;
+               assert(dst_channels);
                if ((result = snd_pcm_plugin_dst_frames_to_size(plugin, frames)) < 0)
                        return result;
                count = plugin->dst_format.channels;
@@ -110,8 +106,9 @@ static ssize_t io_transfer(snd_pcm_plugin_t *plugin,
                        return result;
                return snd_pcm_plugin_dst_size_to_frames(plugin, result);
        } else {
-               return -EINVAL;
+               assert(0);
        }
+       return 0;
 }
  
 static ssize_t io_src_channels(snd_pcm_plugin_t *plugin,
@@ -140,11 +137,9 @@ int snd_pcm_plugin_build_io(snd_pcm_plugin_handle_t *pcm,
        io_t *data;
        snd_pcm_plugin_t *plugin;
 
-       if (r_plugin == NULL)
-               return -EINVAL;
+       assert(r_plugin);
        *r_plugin = NULL;
-       if (pcm == NULL || format == NULL)
-               return -EINVAL;
+       assert(pcm && format);
        err = snd_pcm_plugin_build(pcm, stream,
                                   "I/O io",
                                   format, format,

diff --git a/src/pcm/plugin/linear.c b/src/pcm/plugin/linear.c
index 5ad125627b8bb83c66beb2c309ea09b1f8ffca41..2ede815e8396ae9010435fedea8f163afb1e3a6e 100644 (file)
--- a/src/pcm/plugin/linear.c
+++ b/src/pcm/plugin/linear.c
@@ -92,18 +92,15 @@ static ssize_t linear_transfer(snd_pcm_plugin_t *plugin,
        linear_t *data;
        unsigned int channel;
 
-       if (plugin == NULL || src_channels == NULL || dst_channels == NULL)
-               return -EFAULT;
+       assert(plugin && src_channels && dst_channels);
        data = (linear_t *)plugin->extra_data;
        if (frames == 0)
                return 0;
        for (channel = 0; channel < plugin->src_format.channels; channel++) {
-               if (src_channels[channel].area.first % 8 != 0 || 
-                   src_channels[channel].area.step % 8 != 0)
-                       return -EINVAL;
-               if (dst_channels[channel].area.first % 8 != 0 || 
-                   dst_channels[channel].area.step % 8 != 0)
-                       return -EINVAL;
+               assert(src_channels[channel].area.first % 8 == 0 &&
+                      src_channels[channel].area.step % 8 == 0);
+               assert(dst_channels[channel].area.first % 8 == 0 &&
+                      dst_channels[channel].area.step % 8 == 0);
        }
        convert(plugin, src_channels, dst_channels, frames);
        return frames;
@@ -144,17 +141,13 @@ int snd_pcm_plugin_build_linear(snd_pcm_plugin_handle_t *handle,
        struct linear_private_data *data;
        snd_pcm_plugin_t *plugin;
 
-       if (r_plugin == NULL)
-               return -EFAULT;
+       assert(r_plugin);
        *r_plugin = NULL;
 
-       if (src_format->rate != dst_format->rate)
-               return -EINVAL;
-       if (src_format->channels != dst_format->channels)
-               return -EINVAL;
-       if (!(snd_pcm_format_linear(src_format->format) &&
-             snd_pcm_format_linear(dst_format->format)))
-               return -EINVAL;
+       assert(src_format->rate == dst_format->rate);
+       assert(src_format->channels == dst_format->channels);
+       assert(snd_pcm_format_linear(src_format->format) &&
+              snd_pcm_format_linear(dst_format->format));
 
        err = snd_pcm_plugin_build(handle, stream,
                                   "linear format conversion",

diff --git a/src/pcm/plugin/mmap.c b/src/pcm/plugin/mmap.c
index 4425658c84fec05669422d1f97ca1b2f57322b97..a466e7f64fbf03bad2e913140990953c7762da6f 100644 (file)
--- a/src/pcm/plugin/mmap.c
+++ b/src/pcm/plugin/mmap.c
@@ -57,8 +57,7 @@ static ssize_t mmap_src_channels(snd_pcm_plugin_t *plugin,
        int ready;
        unsigned int channel;
 
-       if (plugin == NULL || channels == NULL)
-               return -EINVAL;
+       assert(plugin && channels);
        data = (mmap_t *)plugin->extra_data;
        ctrl = data->control;
        stream = &data->slave->stream[plugin->stream];
@@ -86,8 +85,7 @@ static ssize_t mmap_src_channels(snd_pcm_plugin_t *plugin,
                assert(snd_pcm_mmap_ready(data->slave, plugin->stream));
        }
        pos = ctrl->byte_data % setup->buffer_size;
-       if ((pos * 8) % stream->bits_per_frame != 0)
-               return -EINVAL;
+       assert((pos * 8) % stream->bits_per_frame == 0);
        pos = (pos * 8) / stream->bits_per_frame;
 
        sv = plugin->src_channels;
@@ -125,8 +123,7 @@ static ssize_t mmap_dst_channels(snd_pcm_plugin_t *plugin,
        size_t pos;
        int ready;
 
-       if (plugin == NULL || channels == NULL)
-               return -EINVAL;
+       assert(plugin && channels);
        data = (mmap_t *)plugin->extra_data;
        stream = &data->slave->stream[plugin->stream];
 
@@ -159,8 +156,7 @@ static ssize_t mmap_dst_channels(snd_pcm_plugin_t *plugin,
                assert(snd_pcm_mmap_ready(data->slave, plugin->stream));
        }
        pos = ctrl->byte_data % setup->buffer_size;
-       if ((pos * 8) % stream->bits_per_frame != 0)
-               return -EINVAL;
+       assert((pos * 8) % stream->bits_per_frame == 0);
        pos = (pos * 8) / stream->bits_per_frame;
 
        sv = stream->channels;
@@ -190,16 +186,11 @@ static ssize_t mmap_playback_transfer(snd_pcm_plugin_t *plugin,
        snd_pcm_stream_t *str;
        int err;
 
-       if (plugin == NULL)
-               return -EINVAL;
+       assert(plugin && plugin->prev);
+       assert(src_channels);
        data = (mmap_t *)plugin->extra_data;
-       if (src_channels == NULL)
-               return -EINVAL;
-       if (plugin->prev == NULL)
-               return -EINVAL;
        ctrl = data->control;
-       if (ctrl == NULL)
-               return -EINVAL;
+       assert(ctrl);
        str = &data->slave->stream[SND_PCM_STREAM_PLAYBACK];
        setup = &str->setup;
 
@@ -231,15 +222,10 @@ static ssize_t mmap_capture_transfer(snd_pcm_plugin_t *plugin,
        snd_pcm_mmap_control_t *ctrl;
        snd_pcm_stream_t *str;
 
-       if (plugin == NULL)
-               return -EINVAL;
+       assert(plugin && plugin->next);
        data = (mmap_t *)plugin->extra_data;
-       if (plugin->next == NULL)
-               return -EINVAL;
-
        ctrl = data->control;
-       if (ctrl == NULL)
-               return -EINVAL;
+       assert(ctrl);
        str = &data->slave->stream[SND_PCM_STREAM_CAPTURE];
 
        /* FIXME: not here the increment */
@@ -254,8 +240,7 @@ static int mmap_action(snd_pcm_plugin_t *plugin,
 {
        struct mmap_private_data *data;
 
-       if (plugin == NULL)
-               return -EINVAL;
+       assert(plugin);
        data = (mmap_t *)plugin->extra_data;
        if (action == INIT) {
                snd_pcm_stream_setup_t *setup;
@@ -305,11 +290,9 @@ int snd_pcm_plugin_build_mmap(snd_pcm_plugin_handle_t *pcm,
        mmap_t *data;
        snd_pcm_plugin_t *plugin;
 
-       if (r_plugin == NULL)
-               return -EINVAL;
+       assert(r_plugin);
        *r_plugin = NULL;
-       if (!pcm)
-               return -EINVAL;
+       assert(pcm);
        err = snd_pcm_plugin_build(pcm, stream,
                                   "I/O mmap",
                                   format, format,

diff --git a/src/pcm/plugin/mulaw.c b/src/pcm/plugin/mulaw.c
index 4fad6704552367c1f969905df8cfde99ff106bbd..cc46159200da06d0daf3f5cb49b745d2a78126a9 100644 (file)
--- a/src/pcm/plugin/mulaw.c
+++ b/src/pcm/plugin/mulaw.c
@@ -250,17 +250,14 @@ static ssize_t mulaw_transfer(snd_pcm_plugin_t *plugin,
        mulaw_t *data;
        unsigned int channel;
 
-       if (plugin == NULL || src_channels == NULL || dst_channels == NULL)
-               return -EFAULT;
+       assert(plugin && src_channels && dst_channels);
        if (frames == 0)
                return 0;
        for (channel = 0; channel < plugin->src_format.channels; channel++) {
-               if (src_channels[channel].area.first % 8 != 0 || 
-                   src_channels[channel].area.step % 8 != 0)
-                       return -EINVAL;
-               if (dst_channels[channel].area.first % 8 != 0 || 
-                   dst_channels[channel].area.step % 8 != 0)
-                       return -EINVAL;
+               assert(src_channels[channel].area.first % 8 == 0 &&
+                      src_channels[channel].area.step % 8 == 0);
+               assert(dst_channels[channel].area.first % 8 == 0 &&
+                      dst_channels[channel].area.step % 8 == 0);
        }
        data = (mulaw_t *)plugin->extra_data;
        data->func(plugin, src_channels, dst_channels, frames);
@@ -279,14 +276,11 @@ int snd_pcm_plugin_build_mulaw(snd_pcm_plugin_handle_t *handle,
        snd_pcm_format_t *format;
        mulaw_f func;
 
-       if (r_plugin == NULL)
-               return -EINVAL;
+       assert(r_plugin);
        *r_plugin = NULL;
 
-       if (src_format->rate != dst_format->rate)
-               return -EINVAL;
-       if (src_format->channels != dst_format->channels)
-               return -EINVAL;
+       assert(src_format->rate == dst_format->rate);
+       assert(src_format->channels == dst_format->channels);
 
        if (dst_format->format == SND_PCM_SFMT_MU_LAW) {
                format = src_format;
@@ -296,10 +290,11 @@ int snd_pcm_plugin_build_mulaw(snd_pcm_plugin_handle_t *handle,
                format = dst_format;
                func = mulaw_decode;
        }
-       else
-               return -EINVAL;
-       if (!snd_pcm_format_linear(format->format))
+       else {
+               assert(0);
                return -EINVAL;
+       }
+       assert(snd_pcm_format_linear(format->format));
 
        err = snd_pcm_plugin_build(handle, stream,
                                   "Mu-Law<->linear conversion",

diff --git a/src/pcm/plugin/rate.c b/src/pcm/plugin/rate.c
index f829b59e10122335a21eaa390fbb0b1f9f155c00..2383ddbdca411c095b49ccd77fe80ec7dac85e29 100644 (file)
--- a/src/pcm/plugin/rate.c
+++ b/src/pcm/plugin/rate.c
@@ -241,8 +241,9 @@ static ssize_t rate_src_frames(snd_pcm_plugin_t *plugin, size_t frames)
        rate_t *data;
        ssize_t res;
 
-       if (plugin == NULL || frames <= 0)
-               return -EINVAL;
+       assert(plugin);
+       if (frames == 0)
+               return 0;
        data = (rate_t *)plugin->extra_data;
        if (plugin->src_format.rate < plugin->dst_format.rate) {
                res = (((frames * data->pitch) + (BITS/2)) >> SHIFT);
@@ -272,8 +273,9 @@ static ssize_t rate_dst_frames(snd_pcm_plugin_t *plugin, size_t frames)
        rate_t *data;
        ssize_t res;
 
-       if (plugin == NULL || frames <= 0)
-               return -EINVAL;
+       assert(plugin);
+       if (frames == 0)
+               return 0;
        data = (rate_t *)plugin->extra_data;
        if (plugin->src_format.rate < plugin->dst_format.rate) {
                res = (((frames << SHIFT) + (data->pitch / 2)) / data->pitch);
@@ -307,17 +309,14 @@ static ssize_t rate_transfer(snd_pcm_plugin_t *plugin,
        unsigned int channel;
        rate_t *data;
 
-       if (plugin == NULL || src_channels == NULL || dst_channels == NULL)
-               return -EFAULT;
+       assert(plugin && src_channels && dst_channels);
        if (frames == 0)
                return 0;
        for (channel = 0; channel < plugin->src_format.channels; channel++) {
-               if (src_channels[channel].area.first % 8 != 0 || 
-                   src_channels[channel].area.step % 8 != 0)
-                       return -EINVAL;
-               if (dst_channels[channel].area.first % 8 != 0 || 
-                   dst_channels[channel].area.step % 8 != 0)
-                       return -EINVAL;
+               assert(src_channels[channel].area.first % 8 == 0 &&
+                      src_channels[channel].area.step % 8 == 0);
+               assert(dst_channels[channel].area.first % 8 == 0 &&
+                      dst_channels[channel].area.step % 8 == 0);
        }
 
        dst_frames = rate_dst_frames(plugin, frames);
@@ -330,8 +329,7 @@ static int rate_action(snd_pcm_plugin_t *plugin,
                       snd_pcm_plugin_action_t action,
                       unsigned long udata UNUSED)
 {
-       if (plugin == NULL)
-               return -EINVAL;
+       assert(plugin);
        switch (action) {
        case INIT:
        case PREPARE:
@@ -355,20 +353,14 @@ int snd_pcm_plugin_build_rate(snd_pcm_plugin_handle_t *handle,
        rate_t *data;
        snd_pcm_plugin_t *plugin;
 
-       if (r_plugin == NULL)
-               return -EINVAL;
+       assert(r_plugin);
        *r_plugin = NULL;
 
-       if (src_format->channels != dst_format->channels)
-               return -EINVAL;
-       if (src_format->channels < 1)
-               return -EINVAL;
-       if (snd_pcm_format_linear(src_format->format) <= 0)
-               return -EINVAL;
-       if (snd_pcm_format_linear(dst_format->format) <= 0)
-               return -EINVAL;
-       if (src_format->rate == dst_format->rate)
-               return -EINVAL;
+       assert(src_format->channels == dst_format->channels);
+       assert(src_format->channels > 0);
+       assert(snd_pcm_format_linear(src_format->format) > 0);
+       assert(snd_pcm_format_linear(dst_format->format) > 0);
+       assert(src_format->rate != dst_format->rate);
 
        err = snd_pcm_plugin_build(handle, stream,
                                   "rate conversion",

diff --git a/src/pcm/plugin/route.c b/src/pcm/plugin/route.c
index f403259c9f3b6b7368ead369e3cf462bedbb0176..4112e1f60b811395066c9eae546d5a47ac1ef3d6 100644 (file)
--- a/src/pcm/plugin/route.c
+++ b/src/pcm/plugin/route.c
@@ -438,8 +438,7 @@ static int route_load_ttable(snd_pcm_plugin_t *plugin,
                int nsrcs = 0;
                ttable_src_t srcs[plugin->src_format.channels];
                for (src_channel = 0; src_channel < plugin->src_format.channels; ++src_channel) {
-                       if (*sptr < 0 || *sptr > FULL)
-                               return -EINVAL;
+                       assert(*sptr >= 0 && *sptr <= FULL);
                        if (*sptr != 0) {
                                srcs[nsrcs].channel = src_channel;
 #if ROUTE_PLUGIN_USE_FLOAT
@@ -457,8 +456,7 @@ static int route_load_ttable(snd_pcm_plugin_t *plugin,
                        sptr++;
                }
 #if 0
-               if (t > FULL)
-                       return -EINVAL;
+               assert(t <= FULL);
 #endif
                dptr->att = att;
                dptr->nsrcs = nsrcs;
@@ -494,24 +492,21 @@ static ssize_t route_transfer(snd_pcm_plugin_t *plugin,
        ttable_dst_t *ttp;
        snd_pcm_plugin_channel_t *dvp;
 
-       if (plugin == NULL || src_channels == NULL || dst_channels == NULL)
-               return -EFAULT;
+       assert(plugin && src_channels && dst_channels);
        if (frames == 0)
                return 0;
        data = (route_t *)plugin->extra_data;
 
        src_nchannels = plugin->src_format.channels;
        for (src_channel = 0; src_channel < src_nchannels; ++src_channel) {
-               if (src_channels[src_channel].area.first % 8 != 0 || 
-                   src_channels[src_channel].area.step % 8 != 0)
-                       return -EINVAL;
+               assert(src_channels[src_channel].area.first % 8 == 0 &&
+                      src_channels[src_channel].area.step % 8 == 0);
        }
 
        dst_nchannels = plugin->dst_format.channels;
        for (dst_channel = 0; dst_channel < dst_nchannels; ++dst_channel) {
-               if (dst_channels[dst_channel].area.first % 8 != 0 || 
-                   dst_channels[dst_channel].area.step % 8 != 0)
-                       return -EINVAL;
+               assert(dst_channels[dst_channel].area.first % 8 == 0 &&
+                      dst_channels[dst_channel].area.step % 8 == 0);
        }
 
        ttp = data->ttable;
@@ -550,14 +545,11 @@ int snd_pcm_plugin_build_route(snd_pcm_plugin_handle_t *handle,
        snd_pcm_plugin_t *plugin;
        int err;
 
-       if (!r_plugin)
-               return -EFAULT;
+       assert(r_plugin);
        *r_plugin = NULL;
-       if (src_format->rate != dst_format->rate)
-               return -EINVAL;
-       if (!(snd_pcm_format_linear(src_format->format) &&
-             snd_pcm_format_linear(dst_format->format)))
-               return -EINVAL;
+       assert(src_format->rate == dst_format->rate);
+       assert(snd_pcm_format_linear(src_format->format) &&
+              snd_pcm_format_linear(dst_format->format));
 
        err = snd_pcm_plugin_build(handle, stream,
                                   "attenuated route conversion",