Fork us on GitHub Follow us on Facebook Follow us on Twitter

Ignore:
Timestamp:
2012-07-15T15:14:10Z (10 years ago)
Author:
Jan Vesely <jano.vesely@…>
Branches:
lfn, master, serial
Children:
57e8b3b
Parents:
b497018
Message:

Cleanup audio_pcm interface.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/drv/generic/remote_audio_pcm.c

    rb497018 r2cc5c835  
    3333
    3434#include <async.h>
     35#include <devman.h>
    3536#include <ddf/log.h>
    3637#include <errno.h>
     
    5556 * CLIENT SIDE
    5657 */
    57 int audio_pcm_get_info_str(async_exch_t *exch, const char **name)
    58 {
    59         if (!exch)
    60                 return EINVAL;
     58audio_pcm_sess_t *audio_pcm_open(const char *name)
     59{
     60        devman_handle_t device_handle = 0;
     61        const int ret = devman_fun_get_handle(name, &device_handle, 0);
     62        if (ret != EOK)
     63                return NULL;
     64        return devman_device_connect(EXCHANGE_SERIALIZE, device_handle,
     65            IPC_FLAG_BLOCKING);
     66}
     67
     68audio_pcm_sess_t *audio_pcm_open_service(service_id_t id)
     69{
     70        return loc_service_connect(EXCHANGE_SERIALIZE, id, IPC_FLAG_BLOCKING);
     71}
     72
     73void audio_pcm_close(audio_pcm_sess_t *sess)
     74{
     75        if (sess)
     76                async_hangup(sess);
     77}
     78
     79int audio_pcm_get_info_str(audio_pcm_sess_t *sess, const char **name)
     80{
     81        async_exch_t *exch = async_exchange_begin(sess);
    6182        sysarg_t name_size;
    6283        const int ret = async_req_1_1(exch,
     
    6990                         * as it waits for read request */
    7091                        async_data_read_start(exch, (void*)-1, 0);
     92                        async_exchange_end(exch);
    7193                        return ENOMEM;
    7294                }
     
    7597                if (ret != EOK) {
    7698                        free(name_place);
     99                        async_exchange_end(exch);
    77100                        return ret;
    78101                }
    79102                *name = name_place;
    80103        }
    81         return ret;
    82 }
    83 
    84 int audio_pcm_get_buffer(async_exch_t *exch, void **buffer, size_t *size,
     104        async_exchange_end(exch);
     105        return ret;
     106}
     107
     108int audio_pcm_get_buffer(audio_pcm_sess_t *sess, void **buffer, size_t *size,
    85109    async_client_conn_t event_rec, void* arg)
    86110{
    87         if (!exch || !buffer || !size)
     111        if (!buffer || !size)
    88112                return EINVAL;
     113
     114        async_exch_t *exch = async_exchange_begin(sess);
    89115
    90116        sysarg_t buffer_size = *size;
     
    96122                int ret = async_share_in_start_0_0(exch, buffer_size, &dst);
    97123                if (ret != EOK) {
     124                        async_exchange_end(exch);
    98125                        return ret;
    99126                }
    100127                ret = async_connect_to_me(exch, 0, 0, 0, event_rec, arg);
    101128                if (ret != EOK) {
     129                        async_exchange_end(exch);
    102130                        return ret;
    103131                }
     
    106134                *size = buffer_size;
    107135        }
    108         return ret;
    109 }
    110 
    111 int audio_pcm_release_buffer(async_exch_t *exch)
    112 {
    113         if (!exch)
    114                 return EINVAL;
    115         return async_req_1_0(exch, DEV_IFACE_ID(AUDIO_PCM_BUFFER_IFACE),
     136        async_exchange_end(exch);
     137        return ret;
     138}
     139
     140int audio_pcm_release_buffer(audio_pcm_sess_t *sess)
     141{
     142        async_exch_t *exch = async_exchange_begin(sess);
     143        const int ret = async_req_1_0(exch,
     144            DEV_IFACE_ID(AUDIO_PCM_BUFFER_IFACE),
    116145            IPC_M_AUDIO_PCM_RELEASE_BUFFER);
    117 }
    118 
    119 int audio_pcm_start_playback(async_exch_t *exch, unsigned parts,
     146        async_exchange_end(exch);
     147        return ret;
     148}
     149
     150int audio_pcm_start_playback(audio_pcm_sess_t *sess, unsigned parts,
    120151    unsigned channels, unsigned sample_rate, pcm_sample_format_t format)
    121152{
    122         if (!exch)
    123                 return EINVAL;
    124153        if (parts > UINT8_MAX || channels > UINT8_MAX)
    125154                return EINVAL;
     
    127156        const sysarg_t packed =
    128157            (parts << 24) | (channels << 16) | (format & UINT16_MAX);
    129         return async_req_3_0(exch, DEV_IFACE_ID(AUDIO_PCM_BUFFER_IFACE),
    130             IPC_M_AUDIO_PCM_START_PLAYBACK, sample_rate, packed);
    131 }
    132 
    133 int audio_pcm_stop_playback(async_exch_t *exch)
    134 {
    135         if (!exch)
    136                 return EINVAL;
    137         return async_req_1_0(exch, DEV_IFACE_ID(AUDIO_PCM_BUFFER_IFACE),
     158        async_exch_t *exch = async_exchange_begin(sess);
     159        const int ret = async_req_3_0(exch,
     160            DEV_IFACE_ID(AUDIO_PCM_BUFFER_IFACE),
     161            IPC_M_AUDIO_PCM_START_PLAYBACK,
     162            sample_rate, packed);
     163        async_exchange_end(exch);
     164        return ret;
     165}
     166
     167int audio_pcm_stop_playback(audio_pcm_sess_t *sess)
     168{
     169        async_exch_t *exch = async_exchange_begin(sess);
     170        const int ret = async_req_1_0(exch,
     171            DEV_IFACE_ID(AUDIO_PCM_BUFFER_IFACE),
    138172            IPC_M_AUDIO_PCM_STOP_PLAYBACK);
    139 }
    140 
    141 int audio_pcm_start_record(async_exch_t *exch, unsigned parts,
     173        async_exchange_end(exch);
     174        return ret;
     175}
     176
     177int audio_pcm_start_record(audio_pcm_sess_t *sess, unsigned parts,
    142178    unsigned channels, unsigned sample_rate, pcm_sample_format_t format)
    143179{
    144         if (!exch)
    145                 return EINVAL;
    146180        if (parts > UINT8_MAX || channels > UINT8_MAX)
    147181                return EINVAL;
     
    149183        const sysarg_t packed =
    150184            (parts << 24) | (channels << 16) | (format & UINT16_MAX);
    151         return async_req_3_0(exch, DEV_IFACE_ID(AUDIO_PCM_BUFFER_IFACE),
    152             IPC_M_AUDIO_PCM_START_RECORD, sample_rate, packed);
    153 }
    154 
    155 int audio_pcm_stop_record(async_exch_t *exch)
    156 {
    157         if (!exch)
    158                 return EINVAL;
    159         return async_req_1_0(exch, DEV_IFACE_ID(AUDIO_PCM_BUFFER_IFACE),
    160             IPC_M_AUDIO_PCM_STOP_RECORD);
     185        async_exch_t *exch = async_exchange_begin(sess);
     186        const int ret = async_req_3_0(exch,
     187            DEV_IFACE_ID(AUDIO_PCM_BUFFER_IFACE), IPC_M_AUDIO_PCM_START_RECORD,
     188            sample_rate, packed);
     189        async_exchange_end(exch);
     190        return ret;
     191}
     192
     193int audio_pcm_stop_record(audio_pcm_sess_t *sess)
     194{
     195        async_exch_t *exch = async_exchange_begin(sess);
     196        const int ret = async_req_1_0(exch,
     197            DEV_IFACE_ID(AUDIO_PCM_BUFFER_IFACE), IPC_M_AUDIO_PCM_STOP_RECORD);
     198        async_exchange_end(exch);
     199        return ret;
    161200}
    162201
Note: See TracChangeset for help on using the changeset viewer.