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     pthread_mutex_init(&ah->device.pcm_lock, NULL);
  34     ah->device.pcm_count = 0;
  35
  36     return AUDIO_RET_OK;
  37 }
  38
  39 audio_return_t _audio_pcm_deinit(audio_hal_t *ah)
  40 {
  41     AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
  42
  43     pthread_mutex_destroy(&ah->device.pcm_lock);
  44
  45     return AUDIO_RET_OK;
  46 }
  47
  48 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)
  49 {
  50     audio_return_t audio_ret = AUDIO_RET_OK;
  51     audio_hal_t *ah = NULL;
  52
  53     AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
  54     AUDIO_RETURN_VAL_IF_FAIL(pcm_handle, AUDIO_ERR_PARAMETER);
  55     AUDIO_RETURN_VAL_IF_FAIL(sample_spec, AUDIO_ERR_PARAMETER);
  56     AUDIO_RETURN_VAL_IF_FAIL((period_size > 0), AUDIO_ERR_PARAMETER);
  57     AUDIO_RETURN_VAL_IF_FAIL((periods > 0), AUDIO_ERR_PARAMETER);
  58
  59     if ((audio_ret = _pcm_open(pcm_handle, direction, sample_spec, period_size, periods)))
  60         return audio_ret;
  61
  62     ah = (audio_hal_t*)audio_handle;
  63     ah->device.pcm_count++;
  64     AUDIO_LOG_INFO("Opening PCM handle 0x%x", *pcm_handle);
  65
  66     return AUDIO_RET_OK;
  67 }
  68
  69 audio_return_t audio_pcm_start(void *audio_handle, void *pcm_handle)
  70 {
  71     audio_return_t audio_ret = AUDIO_RET_OK;
  72
  73     AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
  74     AUDIO_RETURN_VAL_IF_FAIL(pcm_handle, AUDIO_ERR_PARAMETER);
  75
  76     audio_ret = _pcm_start(pcm_handle);
  77
  78     return audio_ret;
  79 }
  80
  81 audio_return_t audio_pcm_stop(void *audio_handle, void *pcm_handle)
  82 {
  83     audio_return_t audio_ret = AUDIO_RET_OK;
  84
  85     AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
  86     AUDIO_RETURN_VAL_IF_FAIL(pcm_handle, AUDIO_ERR_PARAMETER);
  87
  88     audio_ret = _pcm_stop(pcm_handle);
  89
  90     return audio_ret;
  91 }
  92
  93 audio_return_t audio_pcm_close(void *audio_handle, void *pcm_handle)
  94 {
  95     audio_return_t audio_ret = AUDIO_RET_OK;
  96     audio_hal_t *ah = NULL;
  97
  98     AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
  99     AUDIO_RETURN_VAL_IF_FAIL(pcm_handle, AUDIO_ERR_PARAMETER);
 100
 101     if ((audio_ret = _pcm_close(pcm_handle)))
 102         return audio_ret;
 103
 104     pcm_handle = NULL;
 105     ah = (audio_hal_t*)audio_handle;
 106     ah->device.pcm_count--;
 107
 108     AUDIO_LOG_INFO("PCM handle close success (count:%d)", ah->device.pcm_count);
 109
 110     return audio_ret;
 111 }
 112
 113 audio_return_t audio_pcm_avail(void *audio_handle, void *pcm_handle, uint32_t *avail)
 114 {
 115     audio_return_t audio_ret = AUDIO_RET_OK;
 116
 117     AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
 118     AUDIO_RETURN_VAL_IF_FAIL(pcm_handle, AUDIO_ERR_PARAMETER);
 119     AUDIO_RETURN_VAL_IF_FAIL(avail, AUDIO_ERR_PARAMETER);
 120
 121     audio_ret = _pcm_avail(pcm_handle, avail);
 122
 123     return audio_ret;
 124 }
 125
 126 audio_return_t audio_pcm_write(void *audio_handle, void *pcm_handle, const void *buffer, uint32_t frames)
 127 {
 128     audio_return_t audio_ret = AUDIO_RET_OK;
 129
 130     AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
 131     AUDIO_RETURN_VAL_IF_FAIL(pcm_handle, AUDIO_ERR_PARAMETER);
 132
 133     audio_ret = _pcm_write(pcm_handle, buffer, frames);
 134
 135     return audio_ret;
 136 }
 137
 138 audio_return_t audio_pcm_read(void *audio_handle, void *pcm_handle, void *buffer, uint32_t frames)
 139 {
 140     audio_return_t audio_ret = AUDIO_RET_OK;
 141
 142     AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
 143     AUDIO_RETURN_VAL_IF_FAIL(pcm_handle, AUDIO_ERR_PARAMETER);
 144
 145     audio_ret = _pcm_read(pcm_handle, buffer, frames);
 146
 147     return audio_ret;
 148 }
 149
 150 audio_return_t audio_pcm_get_fd(void *audio_handle, void *pcm_handle, int *fd)
 151 {
 152     audio_return_t audio_ret = AUDIO_RET_OK;
 153
 154     AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
 155     AUDIO_RETURN_VAL_IF_FAIL(pcm_handle, AUDIO_ERR_PARAMETER);
 156     AUDIO_RETURN_VAL_IF_FAIL(fd, AUDIO_ERR_PARAMETER);
 157
 158     audio_ret = _pcm_get_fd(pcm_handle, fd);
 159
 160     return audio_ret;
 161 }
 162
 163 audio_return_t audio_pcm_recover(void *audio_handle, void *pcm_handle, int revents)
 164 {
 165     audio_return_t audio_ret = AUDIO_RET_OK;
 166
 167     AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
 168     AUDIO_RETURN_VAL_IF_FAIL(pcm_handle, AUDIO_ERR_PARAMETER);
 169
 170     audio_ret = _pcm_recover(pcm_handle, revents);
 171
 172     return audio_ret;
 173 }
 174
 175 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)
 176 {
 177     audio_return_t audio_ret = AUDIO_RET_OK;
 178
 179     AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
 180     AUDIO_RETURN_VAL_IF_FAIL(pcm_handle, AUDIO_ERR_PARAMETER);
 181     AUDIO_RETURN_VAL_IF_FAIL(sample_spec, AUDIO_ERR_PARAMETER);
 182     AUDIO_RETURN_VAL_IF_FAIL(period_size, AUDIO_ERR_PARAMETER);
 183     AUDIO_RETURN_VAL_IF_FAIL(periods, AUDIO_ERR_PARAMETER);
 184
 185     audio_ret = _pcm_get_params(pcm_handle, direction, sample_spec, period_size, periods);
 186
 187     return audio_ret;
 188 }
 189
 190 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)
 191 {
 192     audio_return_t audio_ret = AUDIO_RET_OK;
 193
 194     AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
 195     AUDIO_RETURN_VAL_IF_FAIL(pcm_handle, AUDIO_ERR_PARAMETER);
 196     AUDIO_RETURN_VAL_IF_FAIL(sample_spec, AUDIO_ERR_PARAMETER);
 197     AUDIO_RETURN_VAL_IF_FAIL(period_size, AUDIO_ERR_PARAMETER);
 198     AUDIO_RETURN_VAL_IF_FAIL(periods, AUDIO_ERR_PARAMETER);
 199
 200     audio_ret = _pcm_set_params(pcm_handle, direction, sample_spec, period_size, periods);
 201
 202     return audio_ret;
 203 }