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

Changeset 1df3018a in mainline for uspace/srv/audio/hound/main.c


Ignore:
Timestamp:
2012-07-13T03:24:17Z (10 years ago)
Author:
Jan Vesely <jano.vesely@…>
Branches:
lfn, master, serial
Children:
d93a5a6f
Parents:
d01e635
Message:

hound: Only few more TODOs left

File:
1 edited

Legend:

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

    rd01e635 r1df3018a  
    4747#define NAMESPACE "audio"
    4848#define NAME "hound"
    49 
    5049#define CATEGORY "audio-pcm"
    5150
     51#include "audio_client.h"
    5252#include "log.h"
    53 
    54 hound_t hound;
     53#include "protocol.h"
     54
     55static hound_t hound;
     56
     57static inline audio_format_t read_format(const ipc_call_t *call)
     58{
     59        audio_format_t format = {
     60                .channels = IPC_GET_ARG1(*call),
     61                .sampling_rate = IPC_GET_ARG2(*call),
     62                .sample_format = IPC_GET_ARG3(*call),
     63        };
     64        return format;
     65}
     66static inline const char *get_name()
     67{
     68        size_t size = 0;
     69        ipc_callid_t callid;
     70        async_data_read_receive(&callid, &size);
     71        char *buffer = malloc(size);
     72        if (buffer) {
     73                async_data_read_finalize(callid, buffer, size);
     74                buffer[size - 1] = 0;
     75                log_verbose("Got name from client: %s", buffer);
     76        }
     77        return buffer;
     78}
     79static inline async_sess_t *get_session()
     80{
     81        ipc_call_t call;
     82        ipc_callid_t callid = async_get_call(&call);
     83        async_sess_t *s = async_callback_receive_start(EXCHANGE_ATOMIC, &call);
     84        async_answer_0(callid, s ? EOK : ENOMEM);
     85        log_verbose("Received callback session");
     86        return s;
     87}
     88
    5589
    5690static void scan_for_devices(void)
     
    96130
    97131        free(svcs);
    98 
    99 }
    100 
     132}
     133
     134static void client_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
     135{
     136        async_answer_0(iid, EOK);
     137
     138        LIST_INITIALIZE(local_playback);
     139        LIST_INITIALIZE(local_recording);
     140
     141        while (1) {
     142                ipc_call_t call;
     143                ipc_callid_t callid = async_get_call(&call);
     144                log_debug("Got method %u", IPC_GET_IMETHOD(call));
     145                switch (IPC_GET_IMETHOD(call)) {
     146                case HOUND_REGISTER_PLAYBACK: {
     147                        const audio_format_t format = read_format(&call);
     148                        const char *name = get_name();
     149                        async_sess_t *sess = get_session();
     150                        audio_client_t * client =
     151                            audio_client_get_playback(name, &format, sess);
     152                        if (!client) {
     153                                log_error("Failed to create playback client");
     154                                async_answer_0(callid, ENOMEM);
     155                        }
     156                        int ret = hound_add_source(&hound, &client->source);
     157                        if (ret != EOK){
     158                                audio_client_destroy(client);
     159                                log_error("Failed to add audio source: %s",
     160                                    str_error(ret));
     161                                async_answer_0(callid, ret);
     162                                break;
     163                        }
     164                        async_answer_0(callid, EOK);
     165                        list_append(&client->link, &local_playback);
     166                        break;
     167                }
     168                case HOUND_REGISTER_RECORDING: {
     169                        const audio_format_t format = read_format(&call);
     170                        const char *name = get_name();
     171                        async_sess_t *sess = get_session();
     172                        audio_client_t * client =
     173                            audio_client_get_recording(name, &format, sess);
     174                        if (!client) {
     175                                log_error("Failed to create recording client");
     176                                async_answer_0(callid, ENOMEM);
     177                                break;
     178                        }
     179                        int ret = hound_add_sink(&hound, &client->sink);
     180                        if (ret != EOK){
     181                                audio_client_destroy(client);
     182                                log_error("Failed to add audio sink: %s",
     183                                    str_error(ret));
     184                                async_answer_0(callid, ret);
     185                                break;
     186                        }
     187                        async_answer_0(callid, EOK);
     188                        list_append(&client->link, &local_recording);
     189                        break;
     190                }
     191                case HOUND_UNREGISTER_PLAYBACK: {
     192                        //const char *name = get_name();
     193                        //TODO unregister in hound
     194                        //TODO remove from local
     195                        break;
     196                }
     197                case HOUND_UNREGISTER_RECORDING: {
     198                        //TODO Get Name
     199                        //TODO unregister in hound
     200                        //TODO remove from local
     201                        break;
     202                }
     203                case HOUND_CONNECT: {
     204                        //TODO Get Name
     205                        //TODO Get Name
     206                        //TODO connect in hound
     207                        break;
     208                }
     209                case HOUND_DISCONNECT: {
     210                        //TODO Get Name
     211                        //TODO Get Name
     212                        //TODO disconnect in hound
     213                        break;
     214                }
     215                default:
     216                        async_answer_0(callid, ENOTSUP);
     217                        break;
     218                case 0:
     219                        return;
     220                }
     221        }
     222}
    101223
    102224int main(int argc, char **argv)
     
    106228        int ret = hound_init(&hound);
    107229        if (ret != EOK) {
    108                 log_error("Failed to initialize hound structure: %s\n",
    109                     str_error(ret));
    110                 return 1;
     230                log_fatal("Failed to initialize hound structure: %s",
     231                    str_error(ret));
     232                return -ret;
     233        }
     234
     235        async_set_client_connection(client_connection);
     236        ret = loc_server_register(NAME);
     237        if (ret != EOK) {
     238                log_fatal("Failed to register sound server: %s",
     239                    str_error(ret));
     240                return -ret;
     241        }
     242
     243        char fqdn[LOC_NAME_MAXLEN + 1];
     244        snprintf(fqdn, LOC_NAME_MAXLEN, "%s/%s", NAMESPACE, NAME);
     245        service_id_t id = 0;
     246        ret = loc_service_register(fqdn, &id);
     247        if (ret != EOK) {
     248                log_fatal("Failed to register sound service: %s",
     249                    str_error(ret));
     250                return -ret;
    111251        }
    112252
    113253        ret = loc_register_cat_change_cb(scan_for_devices);
     254        if (ret != EOK) {
     255                log_fatal("Failed to register for category changes: %s",
     256                    str_error(ret));
     257                loc_service_unregister(id);
     258                return -ret;
     259        }
     260        log_info("Running with service id %u", id);
    114261
    115262        scan_for_devices();
    116 
    117263
    118264        async_manager();
Note: See TracChangeset for help on using the changeset viewer.