ALSA: pcm: Clean up with snd_pcm_avail() and snd_pcm_hw_avail() helpers

Introduce two new direction-neutral helpers to calculate the avail and
hw_avail values, and clean up the code with them.

The two separated forward and rewind functions are gathered to the
unified functions.

No functional change but only code reductions.

Reviewed-by: Takashi Sakamoto <o-takashi@sakamocchi.jp>
Signed-off-by: Takashi Iwai <tiwai@suse.de>

diff --git a/sound/core/pcm_compat.c b/sound/core/pcm_compat.c
index b719d0bd833ecb6d7560380db5eb3b78a9b040c4..0be248543f1e57f771cbd5c4216cfaab3aca5754 100644 (file)
--- a/sound/core/pcm_compat.c
+++ b/sound/core/pcm_compat.c
@@ -44,10 +44,7 @@ static int snd_pcm_ioctl_rewind_compat(struct snd_pcm_substream *substream,
 
        if (get_user(frames, src))
                return -EFAULT;
-       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
-               err = snd_pcm_playback_rewind(substream, frames);
-       else
-               err = snd_pcm_capture_rewind(substream, frames);
+       err = snd_pcm_rewind(substream, frames);
        if (put_user(err, src))
                return -EFAULT;
        return err < 0 ? err : 0;
@@ -61,10 +58,7 @@ static int snd_pcm_ioctl_forward_compat(struct snd_pcm_substream *substream,
 
        if (get_user(frames, src))
                return -EFAULT;
-       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
-               err = snd_pcm_playback_forward(substream, frames);
-       else
-               err = snd_pcm_capture_forward(substream, frames);
+       err = snd_pcm_forward(substream, frames);
        if (put_user(err, src))
                return -EFAULT;
        return err < 0 ? err : 0;

diff --git a/sound/core/pcm_lib.c b/sound/core/pcm_lib.c
index f4a19509cccf3c481aaa641de2c47c894dd1e66c..44b5ae83308215cddd0c027048346e727ff95382 100644 (file)
--- a/sound/core/pcm_lib.c
+++ b/sound/core/pcm_lib.c
@@ -191,10 +191,7 @@ int snd_pcm_update_state(struct snd_pcm_substream *substream,
 {
        snd_pcm_uframes_t avail;
 
-       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
-               avail = snd_pcm_playback_avail(runtime);
-       else
-               avail = snd_pcm_capture_avail(runtime);
+       avail = snd_pcm_avail(substream);
        if (avail > runtime->avail_max)
                runtime->avail_max = avail;
        if (runtime->status->state == SNDRV_PCM_STATE_DRAINING) {
@@ -1856,10 +1853,7 @@ static int wait_for_avail(struct snd_pcm_substream *substream,
                 * This check must happen after been added to the waitqueue
                 * and having current state be INTERRUPTIBLE.
                 */
-               if (is_playback)
-                       avail = snd_pcm_playback_avail(runtime);
-               else
-                       avail = snd_pcm_capture_avail(runtime);
+               avail = snd_pcm_avail(substream);
                if (avail >= runtime->twake)
                        break;
                snd_pcm_stream_unlock_irq(substream);
@@ -2175,10 +2169,7 @@ snd_pcm_sframes_t __snd_pcm_lib_xfer(struct snd_pcm_substream *substream,
        runtime->twake = runtime->control->avail_min ? : 1;
        if (runtime->status->state == SNDRV_PCM_STATE_RUNNING)
                snd_pcm_update_hw_ptr(substream);
-       if (is_playback)
-               avail = snd_pcm_playback_avail(runtime);
-       else
-               avail = snd_pcm_capture_avail(runtime);
+       avail = snd_pcm_avail(substream);
        while (size > 0) {
                snd_pcm_uframes_t frames, appl_ptr, appl_ofs;
                snd_pcm_uframes_t cont;

diff --git a/sound/core/pcm_local.h b/sound/core/pcm_local.h
index 16f254732b2a4e88c80588126073fab11b425370..7a499d02df6cf66ecaeb134afeacf89cc9603688 100644 (file)
--- a/sound/core/pcm_local.h
+++ b/sound/core/pcm_local.h
@@ -36,6 +36,24 @@ int snd_pcm_update_hw_ptr(struct snd_pcm_substream *substream);
 void snd_pcm_playback_silence(struct snd_pcm_substream *substream,
                              snd_pcm_uframes_t new_hw_ptr);
 
+static inline snd_pcm_uframes_t
+snd_pcm_avail(struct snd_pcm_substream *substream)
+{
+       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
+               return snd_pcm_playback_avail(substream->runtime);
+       else
+               return snd_pcm_capture_avail(substream->runtime);
+}
+
+static inline snd_pcm_uframes_t
+snd_pcm_hw_avail(struct snd_pcm_substream *substream)
+{
+       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
+               return snd_pcm_playback_hw_avail(substream->runtime);
+       else
+               return snd_pcm_capture_hw_avail(substream->runtime);
+}
+
 #ifdef CONFIG_SND_PCM_TIMER
 void snd_pcm_timer_resolution_change(struct snd_pcm_substream *substream);
 void snd_pcm_timer_init(struct snd_pcm_substream *substream);

diff --git a/sound/core/pcm_native.c b/sound/core/pcm_native.c
index 35ffccea94c3eb6cfe7755b6c1da7547d018a9a0..f69d89c907b9fb0a796fd8ec48a8864f57d1caaf 100644 (file)
--- a/sound/core/pcm_native.c
+++ b/sound/core/pcm_native.c
@@ -908,8 +908,8 @@ int snd_pcm_status(struct snd_pcm_substream *substream,
  _tstamp_end:
        status->appl_ptr = runtime->control->appl_ptr;
        status->hw_ptr = runtime->status->hw_ptr;
+       status->avail = snd_pcm_avail(substream);
        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
-               status->avail = snd_pcm_playback_avail(runtime);
                if (runtime->status->state == SNDRV_PCM_STATE_RUNNING ||
                    runtime->status->state == SNDRV_PCM_STATE_DRAINING) {
                        status->delay = runtime->buffer_size - status->avail;
@@ -917,7 +917,6 @@ int snd_pcm_status(struct snd_pcm_substream *substream,
                } else
                        status->delay = 0;
        } else {
-               status->avail = snd_pcm_capture_avail(runtime);
                if (runtime->status->state == SNDRV_PCM_STATE_RUNNING)
                        status->delay = status->avail + runtime->delay;
                else
@@ -2610,28 +2609,9 @@ static snd_pcm_sframes_t rewind_appl_ptr(struct snd_pcm_substream *substream,
        return ret < 0 ? 0 : frames;
 }
 
-static snd_pcm_sframes_t snd_pcm_playback_rewind(struct snd_pcm_substream *substream,
-                                                snd_pcm_uframes_t frames)
+static snd_pcm_sframes_t snd_pcm_rewind(struct snd_pcm_substream *substream,
+                                       snd_pcm_uframes_t frames)
 {
-       struct snd_pcm_runtime *runtime = substream->runtime;
-       snd_pcm_sframes_t ret;
-
-       if (frames == 0)
-               return 0;
-
-       snd_pcm_stream_lock_irq(substream);
-       ret = do_pcm_hwsync(substream);
-       if (!ret)
-               ret = rewind_appl_ptr(substream, frames,
-                                     snd_pcm_playback_hw_avail(runtime));
-       snd_pcm_stream_unlock_irq(substream);
-       return ret;
-}
-
-static snd_pcm_sframes_t snd_pcm_capture_rewind(struct snd_pcm_substream *substream,
-                                               snd_pcm_uframes_t frames)
-{
-       struct snd_pcm_runtime *runtime = substream->runtime;
        snd_pcm_sframes_t ret;
 
        if (frames == 0)
@@ -2641,33 +2621,14 @@ static snd_pcm_sframes_t snd_pcm_capture_rewind(struct snd_pcm_substream *substr
        ret = do_pcm_hwsync(substream);
        if (!ret)
                ret = rewind_appl_ptr(substream, frames,
-                                     snd_pcm_capture_hw_avail(runtime));
-       snd_pcm_stream_unlock_irq(substream);
-       return ret;
-}
-
-static snd_pcm_sframes_t snd_pcm_playback_forward(struct snd_pcm_substream *substream,
-                                                 snd_pcm_uframes_t frames)
-{
-       struct snd_pcm_runtime *runtime = substream->runtime;
-       snd_pcm_sframes_t ret;
-
-       if (frames == 0)
-               return 0;
-
-       snd_pcm_stream_lock_irq(substream);
-       ret = do_pcm_hwsync(substream);
-       if (!ret)
-               ret = forward_appl_ptr(substream, frames,
-                                      snd_pcm_playback_avail(runtime));
+                                     snd_pcm_hw_avail(substream));
        snd_pcm_stream_unlock_irq(substream);
        return ret;
 }
 
-static snd_pcm_sframes_t snd_pcm_capture_forward(struct snd_pcm_substream *substream,
-                                                snd_pcm_uframes_t frames)
+static snd_pcm_sframes_t snd_pcm_forward(struct snd_pcm_substream *substream,
+                                        snd_pcm_uframes_t frames)
 {
-       struct snd_pcm_runtime *runtime = substream->runtime;
        snd_pcm_sframes_t ret;
 
        if (frames == 0)
@@ -2677,7 +2638,7 @@ static snd_pcm_sframes_t snd_pcm_capture_forward(struct snd_pcm_substream *subst
        ret = do_pcm_hwsync(substream);
        if (!ret)
                ret = forward_appl_ptr(substream, frames,
-                                      snd_pcm_capture_avail(runtime));
+                                      snd_pcm_avail(substream));
        snd_pcm_stream_unlock_irq(substream);
        return ret;
 }
@@ -2830,10 +2791,7 @@ static int snd_pcm_rewind_ioctl(struct snd_pcm_substream *substream,
                return -EFAULT;
        if (put_user(0, _frames))
                return -EFAULT;
-       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
-               result = snd_pcm_playback_rewind(substream, frames);
-       else
-               result = snd_pcm_capture_rewind(substream, frames);
+       result = snd_pcm_rewind(substream, frames);
        __put_user(result, _frames);
        return result < 0 ? result : 0;
 }
@@ -2848,10 +2806,7 @@ static int snd_pcm_forward_ioctl(struct snd_pcm_substream *substream,
                return -EFAULT;
        if (put_user(0, _frames))
                return -EFAULT;
-       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
-               result = snd_pcm_playback_forward(substream, frames);
-       else
-               result = snd_pcm_capture_forward(substream, frames);
+       result = snd_pcm_forward(substream, frames);
        __put_user(result, _frames);
        return result < 0 ? result : 0;
 }
@@ -2992,7 +2947,7 @@ int snd_pcm_kernel_ioctl(struct snd_pcm_substream *substream,
                /* provided only for OSS; capture-only and no value returned */
                if (substream->stream != SNDRV_PCM_STREAM_CAPTURE)
                        return -EINVAL;
-               result = snd_pcm_capture_forward(substream, *frames);
+               result = snd_pcm_forward(substream, *frames);
                return result < 0 ? result : 0;
        }
        case SNDRV_PCM_IOCTL_HW_PARAMS: