Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/srv/audio/hound/audio_device.c

    r7f9d97f3 rb7fd2a0  
    5151#define BUFFER_PARTS   16
    5252
    53 static int device_sink_connection_callback(audio_sink_t *sink, bool new);
    54 static int device_source_connection_callback(audio_source_t *source, bool new);
     53static errno_t device_sink_connection_callback(audio_sink_t *sink, bool new);
     54static errno_t device_source_connection_callback(audio_source_t *source, bool new);
    5555static void device_event_callback(ipc_callid_t iid, ipc_call_t *icall, void *arg);
    56 static int device_check_format(audio_sink_t* sink);
    57 static int get_buffer(audio_device_t *dev);
    58 static int release_buffer(audio_device_t *dev);
     56static errno_t device_check_format(audio_sink_t* sink);
     57static errno_t get_buffer(audio_device_t *dev);
     58static errno_t release_buffer(audio_device_t *dev);
    5959static void advance_buffer(audio_device_t *dev, size_t size);
    6060static inline bool is_running(audio_device_t *dev)
     
    6262        assert(dev);
    6363        /* we release buffer on stop so this should be enough */
    64         return (bool)dev->buffer.base;
     64        return dev->buffer.base != NULL;
    6565}
    6666
     
    7272 * @return Error code.
    7373 */
    74 int audio_device_init(audio_device_t *dev, service_id_t id, const char *name)
     74errno_t audio_device_init(audio_device_t *dev, service_id_t id, const char *name)
    7575{
    7676        assert(dev);
     
    121121{
    122122        assert(dev);
    123         if (audio_pcm_query_cap(dev->sess, AUDIO_CAP_CAPTURE))
     123        sysarg_t val;
     124        errno_t rc = audio_pcm_query_cap(dev->sess, AUDIO_CAP_CAPTURE, &val);
     125        if (rc == EOK && val)
    124126                return &dev->source;
    125127        return NULL;
     
    135137{
    136138        assert(dev);
    137         if (audio_pcm_query_cap(dev->sess, AUDIO_CAP_PLAYBACK))
     139        sysarg_t val;
     140        errno_t rc = audio_pcm_query_cap(dev->sess, AUDIO_CAP_PLAYBACK, &val);
     141        if (rc == EOK && val)
    138142                return &dev->sink;
    139143        return NULL;
     
    149153 * connections.
    150154 */
    151 static int device_sink_connection_callback(audio_sink_t* sink, bool new)
     155static errno_t device_sink_connection_callback(audio_sink_t* sink, bool new)
    152156{
    153157        assert(sink);
     
    156160                log_verbose("First connection on device sink '%s'", sink->name);
    157161
    158                 int ret = get_buffer(dev);
     162                errno_t ret = get_buffer(dev);
    159163                if (ret != EOK) {
    160164                        log_error("Failed to get device buffer: %s",
     
    192196                log_verbose("Removed last connection on device sink '%s'",
    193197                    sink->name);
    194                 int ret = audio_pcm_stop_playback(dev->sess);
     198                errno_t ret = audio_pcm_stop_playback(dev->sess);
    195199                if (ret != EOK) {
    196200                        log_error("Failed to stop playback: %s",
     
    211215 * connections.
    212216 */
    213 static int device_source_connection_callback(audio_source_t *source, bool new)
     217static errno_t device_source_connection_callback(audio_source_t *source, bool new)
    214218{
    215219        assert(source);
    216220        audio_device_t *dev = source->private_data;
    217221        if (new && list_count(&source->connections) == 1) {
    218                 int ret = get_buffer(dev);
     222                errno_t ret = get_buffer(dev);
    219223                if (ret != EOK) {
    220224                        log_error("Failed to get device buffer: %s",
     
    240244        if (list_count(&source->connections) == 0) { /* Disconnected */
    241245                assert(!new);
    242                 int ret = audio_pcm_stop_capture_immediate(dev->sess);
     246                errno_t ret = audio_pcm_stop_capture_immediate(dev->sess);
    243247                if (ret != EOK) {
    244248                        log_error("Failed to start recording: %s",
     
    285289                        log_verbose("Capture terminated");
    286290                        dev->source.format = AUDIO_FORMAT_ANY;
    287                         const int ret = release_buffer(dev);
     291                        const errno_t ret = release_buffer(dev);
    288292                        if (ret != EOK) {
    289293                                log_error("Failed to release buffer: %s",
     
    296300                        log_verbose("Playback Terminated");
    297301                        dev->sink.format = AUDIO_FORMAT_ANY;
    298                         const int ret = release_buffer(dev);
     302                        const errno_t ret = release_buffer(dev);
    299303                        if (ret != EOK) {
    300304                                log_error("Failed to release buffer: %s",
     
    305309                }
    306310                case PCM_EVENT_FRAMES_CAPTURED: {
    307                         const int ret = audio_source_push_data(&dev->source,
     311                        const errno_t ret = audio_source_push_data(&dev->source,
    308312                            dev->buffer.position, dev->buffer.fragment_size);
    309313                        advance_buffer(dev, dev->buffer.fragment_size);
     
    325329 * @return Error code.
    326330 */
    327 static int device_check_format(audio_sink_t* sink)
     331static errno_t device_check_format(audio_sink_t* sink)
    328332{
    329333        assert(sink);
     
    343347 * @return Error code.
    344348 */
    345 static int get_buffer(audio_device_t *dev)
     349static errno_t get_buffer(audio_device_t *dev)
    346350{
    347351        assert(dev);
     
    358362        size_t preferred_size = 0;
    359363
    360         const int ret = audio_pcm_get_buffer(dev->sess, &dev->buffer.base,
     364        const errno_t ret = audio_pcm_get_buffer(dev->sess, &dev->buffer.base,
    361365            &preferred_size);
    362366        if (ret == EOK) {
     
    374378 * @return Error code.
    375379 */
    376 static int release_buffer(audio_device_t *dev)
     380static errno_t release_buffer(audio_device_t *dev)
    377381{
    378382        assert(dev);
    379383        assert(dev->buffer.base);
    380384
    381         const int ret = audio_pcm_release_buffer(dev->sess);
     385        const errno_t ret = audio_pcm_release_buffer(dev->sess);
    382386        if (ret == EOK) {
    383387                as_area_destroy(dev->buffer.base);
Note: See TracChangeset for help on using the changeset viewer.