tizen-audio-pcm.c

   1 /*
   2  * audio-hal
   3  *
   4  * Copyright (c) 2016 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #include <config.h>
  22 #endif
  23
  24 #include "tizen-audio-internal.h"
  25 #include "tizen-audio-impl.h"
  26
  27 audio_return_t _audio_pcm_init(audio_hal_t *ah)
  28 {
  29     AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
  30
  31     ah->device.pcm_in = NULL;
  32     ah->device.pcm_out = NULL;
  33     ah->device.fmradio_pcm_out = NULL;
  34     pthread_mutex_init(&ah->device.pcm_lock, NULL);
  35     pthread_mutex_init(&ah->device.device_lock, NULL);
  36     pthread_cond_init(&ah->device.device_cond, NULL);
  37     ah->device.pcm_count = 0;
  38
  39     return AUDIO_RET_OK;
  40 }
  41
  42 audio_return_t _audio_pcm_deinit(audio_hal_t *ah)
  43 {
  44     AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
  45
  46     pthread_mutex_destroy(&ah->device.pcm_lock);
  47     pthread_mutex_destroy(&ah->device.device_lock);
  48     pthread_cond_destroy(&ah->device.device_cond);
  49
  50     return AUDIO_RET_OK;
  51 }
  52
  53 audio_return_t audio_pcm_open(void *audio_handle, void **pcm_handle, uint32_t direction, void *sample_spec, uint32_t period_size, uint32_t periods)
  54 {
  55     audio_return_t audio_ret = AUDIO_RET_OK;
  56     audio_hal_t *ah = NULL;
  57
  58     AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
  59     AUDIO_RETURN_VAL_IF_FAIL(pcm_handle, AUDIO_ERR_PARAMETER);
  60     AUDIO_RETURN_VAL_IF_FAIL(sample_spec, AUDIO_ERR_PARAMETER);
  61     AUDIO_RETURN_VAL_IF_FAIL((period_size > 0), AUDIO_ERR_PARAMETER);
  62     AUDIO_RETURN_VAL_IF_FAIL((periods > 0), AUDIO_ERR_PARAMETER);
  63
  64     if ((audio_ret = _pcm_open(pcm_handle, direction, sample_spec, period_size, periods)))
  65         return audio_ret;
  66
  67     ah = (audio_hal_t*)audio_handle;
  68     ah->device.pcm_count++;
  69     AUDIO_LOG_INFO("Opening PCM handle 0x%x", *pcm_handle);
  70
  71     return AUDIO_RET_OK;
  72 }
  73
  74 audio_return_t audio_pcm_start(void *audio_handle, void *pcm_handle)
  75 {
  76     audio_return_t audio_ret = AUDIO_RET_OK;
  77
  78     AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
  79     AUDIO_RETURN_VAL_IF_FAIL(pcm_handle, AUDIO_ERR_PARAMETER);
  80
  81     audio_ret = _pcm_start(pcm_handle);
  82
  83     return audio_ret;
  84 }
  85
  86 audio_return_t audio_pcm_stop(void *audio_handle, void *pcm_handle)
  87 {
  88     audio_return_t audio_ret = AUDIO_RET_OK;
  89
  90     AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
  91     AUDIO_RETURN_VAL_IF_FAIL(pcm_handle, AUDIO_ERR_PARAMETER);
  92
  93     audio_ret = _pcm_stop(pcm_handle);
  94
  95     return audio_ret;
  96 }
  97
  98 audio_return_t audio_pcm_close(void *audio_handle, void *pcm_handle)
  99 {
 100     audio_return_t audio_ret = AUDIO_RET_OK;
 101     audio_hal_t *ah = NULL;
 102
 103     AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
 104     AUDIO_RETURN_VAL_IF_FAIL(pcm_handle, AUDIO_ERR_PARAMETER);
 105
 106     if ((audio_ret = _pcm_close(pcm_handle)))
 107         return audio_ret;
 108
 109     pcm_handle = NULL;
 110     ah = (audio_hal_t*)audio_handle;
 111     ah->device.pcm_count--;
 112
 113     AUDIO_LOG_INFO("PCM handle close success (count:%d)", ah->device.pcm_count);
 114
 115     return audio_ret;
 116 }
 117
 118 audio_return_t audio_pcm_avail(void *audio_handle, void *pcm_handle, uint32_t *avail)
 119 {
 120     audio_return_t audio_ret = AUDIO_RET_OK;
 121
 122     AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
 123     AUDIO_RETURN_VAL_IF_FAIL(pcm_handle, AUDIO_ERR_PARAMETER);
 124     AUDIO_RETURN_VAL_IF_FAIL(avail, AUDIO_ERR_PARAMETER);
 125
 126     audio_ret = _pcm_avail(pcm_handle, avail);
 127
 128     return audio_ret;
 129 }
 130
 131 audio_return_t audio_pcm_write(void *audio_handle, void *pcm_handle, const void *buffer, uint32_t frames)
 132 {
 133     audio_return_t audio_ret = AUDIO_RET_OK;
 134
 135     AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
 136     AUDIO_RETURN_VAL_IF_FAIL(pcm_handle, AUDIO_ERR_PARAMETER);
 137
 138     audio_ret = _pcm_write(pcm_handle, buffer, frames);
 139
 140     return audio_ret;
 141 }
 142
 143 audio_return_t audio_pcm_read(void *audio_handle, void *pcm_handle, void *buffer, uint32_t frames)
 144 {
 145     audio_return_t audio_ret = AUDIO_RET_OK;
 146
 147     AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
 148     AUDIO_RETURN_VAL_IF_FAIL(pcm_handle, AUDIO_ERR_PARAMETER);
 149
 150     audio_ret = _pcm_read(pcm_handle, buffer, frames);
 151
 152     return audio_ret;
 153 }
 154
 155 audio_return_t audio_pcm_get_fd(void *audio_handle, void *pcm_handle, int *fd)
 156 {
 157     audio_return_t audio_ret = AUDIO_RET_OK;
 158
 159     AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
 160     AUDIO_RETURN_VAL_IF_FAIL(pcm_handle, AUDIO_ERR_PARAMETER);
 161     AUDIO_RETURN_VAL_IF_FAIL(fd, AUDIO_ERR_PARAMETER);
 162
 163     audio_ret = _pcm_get_fd(pcm_handle, fd);
 164
 165     return audio_ret;
 166 }
 167
 168 audio_return_t audio_pcm_recover(void *audio_handle, void *pcm_handle, int revents)
 169 {
 170     audio_return_t audio_ret = AUDIO_RET_OK;
 171
 172     AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
 173     AUDIO_RETURN_VAL_IF_FAIL(pcm_handle, AUDIO_ERR_PARAMETER);
 174
 175     audio_ret = _pcm_recover(pcm_handle, revents);
 176
 177     return audio_ret;
 178 }
 179
 180 audio_return_t audio_pcm_get_params(void *audio_handle, void *pcm_handle, uint32_t direction, void **sample_spec, uint32_t *period_size, uint32_t *periods)
 181 {
 182     audio_return_t audio_ret = AUDIO_RET_OK;
 183
 184     AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
 185     AUDIO_RETURN_VAL_IF_FAIL(pcm_handle, AUDIO_ERR_PARAMETER);
 186     AUDIO_RETURN_VAL_IF_FAIL(sample_spec, AUDIO_ERR_PARAMETER);
 187     AUDIO_RETURN_VAL_IF_FAIL(period_size, AUDIO_ERR_PARAMETER);
 188     AUDIO_RETURN_VAL_IF_FAIL(periods, AUDIO_ERR_PARAMETER);
 189
 190     audio_ret = _pcm_get_params(pcm_handle, direction, sample_spec, period_size, periods);
 191
 192     return audio_ret;
 193 }
 194
 195 audio_return_t audio_pcm_set_params(void *audio_handle, void *pcm_handle, uint32_t direction, void *sample_spec, uint32_t period_size, uint32_t periods)
 196 {
 197     audio_return_t audio_ret = AUDIO_RET_OK;
 198
 199     AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
 200     AUDIO_RETURN_VAL_IF_FAIL(pcm_handle, AUDIO_ERR_PARAMETER);
 201     AUDIO_RETURN_VAL_IF_FAIL(sample_spec, AUDIO_ERR_PARAMETER);
 202     AUDIO_RETURN_VAL_IF_FAIL(period_size, AUDIO_ERR_PARAMETER);
 203     AUDIO_RETURN_VAL_IF_FAIL(periods, AUDIO_ERR_PARAMETER);
 204
 205     audio_ret = _pcm_set_params(pcm_handle, direction, sample_spec, period_size, periods);
 206
 207     return audio_ret;
 208 }