Lines Matching refs:client
9 * cras_client_connect - Connect client to server - sets up server_fd to
10 * communicate with the audio server. After the client connects, the server
11 * will send back a message containing the client id.
16 * the client should start receving audio events from aud_fd. This message
19 * running - Once the connections are established, the client will listen for
61 /* Commands sent from the user to the running client. */
82 /* Adds a stream to the client.
95 /* Commands send from a running stream to the client. */
142 * client - The client this stream is attached to.
146 * prev, next - Form a linked list of streams attached to a client.
156 struct cras_client *client;
177 * client ID. */
187 /* Represents a client used to communicate with the audio server.
188 * id - Unique identifier for this client, negative until connected.
198 * running - The client thread will run while this is non zero.
202 * tid - Thread ID of the client thread started by "cras_client_run_thread".
204 * streams - Linked list of streams attached to this client.
214 * observer_context - Context passed to client in state change callbacks.
245 * Holds the client pointer plus internal book keeping.
247 * client - The client
248 * server_state_rwlock - lock to make the client's server_state thread-safe.
251 struct cras_client client;
256 ((struct client_int *)((char *)cptr - offsetof(struct client_int, client)))
262 static int client_thread_rm_stream(struct cras_client *client,
264 static int handle_message_from_server(struct cras_client *client);
265 static int reregister_notifications(struct cras_client *client);
271 * client - The CRAS client pointer.
275 static void server_state_unlock(const struct cras_client *client,
280 if (!client)
282 client_int = to_client_int(client);
293 * client - The CRAS client pointer.
298 static int server_state_rdlock(const struct cras_client *client)
303 if (!client)
305 client_int = to_client_int(client);
309 if (!client->server_state) {
320 * client - The CRAS client pointer.
324 static int server_state_wrlock(const struct cras_client *client)
328 if (!client)
330 client_int = to_client_int(client);
335 static struct client_stream *stream_from_id(const struct cras_client *client,
340 DL_SEARCH_SCALAR(client->streams, out, id, id);
347 void server_fill_pollfd(const struct cras_client *client,
352 poll_fd->fd = client->server_fd;
353 switch (client->server_fd_state) {
373 static void server_fd_move_to_state(struct cras_client *client,
376 if (state == client->server_fd_state)
379 client->server_fd_state = state;
393 static int error_delay_next_action(struct cras_client *client,
399 if (client->server_fd == -1) {
400 client->server_fd = timerfd_create(
403 if (client->server_fd == -1) {
414 rc = timerfd_settime(client->server_fd, 0, &timeout, NULL);
428 close(client->server_fd);
429 client->server_fd = -1;
430 server_fd_move_to_state(client, CRAS_SOCKET_STATE_WAIT_FOR_SOCKET);
444 static void wait_for_socket_next_action(struct cras_client *client)
446 if (client->sock_file_exists)
448 client, CRAS_SOCKET_STATE_WAIT_FOR_WRITABLE);
462 static int wait_for_writable_next_action(struct cras_client *client,
468 if (client->server_fd == -1) {
469 client->server_fd = socket(PF_UNIX, SOCK_SEQPACKET, 0);
470 if (client->server_fd < 0) {
483 cras_make_fd_nonblocking(client->server_fd);
487 strcpy(address.sun_path, client->sock_file);
488 rc = connect(client->server_fd, (struct sockaddr *)&address,
500 close(client->server_fd);
501 client->server_fd = -1;
512 cras_make_fd_blocking(client->server_fd);
513 server_fd_move_to_state(client, CRAS_SOCKET_STATE_FIRST_MESSAGE);
520 static int connect_transition_action(struct cras_client *client)
525 rc = reregister_notifications(client);
529 server_fd_move_to_state(client, CRAS_SOCKET_STATE_CONNECTED);
532 eventfd_read(client->server_event_fd, &event_value);
533 eventfd_write(client->server_event_fd, 1);
534 if (client->server_connection_cb)
535 client->server_connection_cb(
536 client, CRAS_CONN_STATUS_CONNECTED,
537 client->server_connection_user_arg);
544 * We are waiting for the first message from the server. When our client ID has
547 static int first_message_next_action(struct cras_client *client,
552 if (client->server_fd < 0)
558 rc = handle_message_from_server(client);
561 } else if (client->id >= 0) {
562 rc = connect_transition_action(client);
601 static void disconnect_transition_action(struct cras_client *client, bool force)
604 cras_socket_state_t old_state = client->server_fd_state;
610 DL_FOREACH(client->streams, s) {
611 s->config->err_cb(client, s->id, -ENOTCONN,
613 client_thread_rm_stream(client, s->id);
617 lock_rc = server_state_wrlock(client);
618 if (client->server_state) {
619 munmap((void *)client->server_state,
620 sizeof(*client->server_state));
621 client->server_state = NULL;
623 server_state_unlock(client, lock_rc);
626 client->id = -1;
629 if (client->server_fd >= 0) {
631 shutdown_and_close_socket(client->server_fd);
633 close(client->server_fd);
634 client->server_fd = -1;
639 eventfd_read(client->server_event_fd, &event_value);
650 client, CRAS_SOCKET_STATE_DISCONNECTED);
651 if (client->server_connection_cb)
652 client->server_connection_cb(
653 client, CRAS_CONN_STATUS_FAILED,
654 client->server_connection_user_arg);
655 else if (client->server_err_cb)
656 client->server_err_cb(
657 client, client->server_connection_user_arg);
666 client, CRAS_SOCKET_STATE_ERROR_DELAY);
672 client, CRAS_SOCKET_STATE_WAIT_FOR_SOCKET);
674 if (client->server_connection_cb)
675 client->server_connection_cb(
676 client, CRAS_CONN_STATUS_DISCONNECTED,
677 client->server_connection_user_arg);
682 static int server_fd_dispatch(struct cras_client *client, int poll_revents)
689 disconnect_transition_action(client, true);
691 old_state = client->server_fd_state;
693 switch (client->server_fd_state) {
698 rc = error_delay_next_action(client, poll_revents);
701 wait_for_socket_next_action(client);
704 rc = wait_for_writable_next_action(client, poll_revents);
707 rc = first_message_next_action(client, poll_revents);
711 rc = handle_message_from_server(client);
717 rc = server_fd_dispatch(client, POLLHUP);
718 } else if (old_state != client->server_fd_state) {
720 rc = server_fd_dispatch(client, 0);
728 static int server_connect(struct cras_client *client)
730 if (client->server_fd_state != CRAS_SOCKET_STATE_DISCONNECTED)
733 server_fd_move_to_state(client, CRAS_SOCKET_STATE_WAIT_FOR_SOCKET);
734 return server_fd_dispatch(client, 0);
740 static void server_disconnect(struct cras_client *client)
742 if (client->server_fd_state == CRAS_SOCKET_STATE_DISCONNECTED)
746 server_fd_move_to_state(client, CRAS_SOCKET_STATE_DISCONNECTED);
747 disconnect_transition_action(client, false);
756 struct cras_client *client = (struct cras_client *)context;
759 client->sock_file_exists = 1;
760 switch (client->server_fd_state) {
770 server_fd_dispatch(client, 0);
775 client->sock_file_exists = 0;
776 switch (client->server_fd_state) {
785 server_disconnect(client);
786 server_connect(client);
801 static int sock_file_wait_dispatch(struct cras_client *client,
809 rc = cras_file_wait_dispatch(client->sock_file_wait);
822 * sends. Return non zero if client is connected to the server. A return code
823 * of zero means that the client is not connected to the server.
825 static int check_server_connected_wait(struct cras_client *client,
831 poll_fd.fd = client->server_event_fd;
855 * client - Client pointer created with cras_client_create().
860 static int connect_to_server(struct cras_client *client,
868 if (!client)
871 if (thread_is_running(&client->thread) && use_command_thread) {
872 rc = cras_client_connect_async(client);
874 rc = check_server_connected_wait(client, timeout);
881 if (check_server_connected_wait(client, &connected_timeout))
884 poll_fd[0].fd = cras_file_wait_get_fd(client->sock_file_wait);
887 rc = server_connect(client);
892 server_fill_pollfd(client, &(poll_fd[1]));
899 client, poll_fd[0].revents);
904 rc = server_fd_dispatch(client, poll_fd[1].revents);
906 client->server_fd_state ==
919 static int connect_to_server_wait_retry(struct cras_client *client,
935 return connect_to_server(client, timeout, use_command_thread);
943 static int connect_to_server_wait(struct cras_client *client,
947 client, SERVER_CONNECT_TIMEOUT_MS, use_command_thread);
954 /* Sends a message from the stream to the client to indicate an error.
955 * If the running stream encounters an error, then it must tell the client
966 res = write(stream->client->stream_fds[1], &msg, sizeof(msg));
1024 /* Don't ask for more frames than the client desires. */
1030 /* If shm readable frames is less than client requests, that means
1032 * buffer to client. */
1052 * 0, unless there is a fatal error or the client declares enod of file.
1076 frames = config->unified_cb(stream->client,
1085 frames = config->aud_cb(stream->client,
1154 frames = config->unified_cb(stream->client,
1163 frames = config->aud_cb(stream->client,
1186 if (stream->client->thread_priority_cb) {
1187 stream->client->thread_priority_cb(stream->client);
1213 pthread_mutex_lock(&stream->client->stream_start_lock);
1214 pthread_cond_broadcast(&stream->client->stream_start_cond);
1215 pthread_mutex_unlock(&stream->client->stream_start_lock);
1304 pthread_mutex_lock(&stream->client->stream_start_lock);
1307 pthread_mutex_unlock(&stream->client->stream_start_lock);
1318 rc = pthread_cond_timedwait(&stream->client->stream_start_cond,
1319 &stream->client->stream_start_lock, &future);
1320 pthread_mutex_unlock(&stream->client->stream_start_lock);
1324 syslog(LOG_ERR, "cras_client: Client thread not responding: %s",
1333 * Client thread.
1452 static int send_connect_message(struct cras_client *client,
1477 rc = cras_send_with_fds(client->server_fd, &serv_msg, sizeof(serv_msg),
1498 /* Adds a stream to a running client. Checks to make sure that the client is
1501 static int client_thread_add_stream(struct cras_client *client,
1514 hotword_idx = cras_client_get_first_dev_type_idx(client,
1526 new_id = cras_get_stream_id(client->id, client->next_stream_id);
1527 client->next_stream_id++;
1528 DL_SEARCH_SCALAR(client->streams, out, id, new_id);
1533 stream->client = client;
1542 rc = send_connect_message(client, stream, dev_idx);
1549 DL_APPEND(client->streams, stream);
1554 /* Removes a stream from a running client from within the running client's
1556 static int client_thread_rm_stream(struct cras_client *client,
1561 stream_from_id(client, stream_id);
1568 if (client->server_fd_state == CRAS_SOCKET_STATE_CONNECTED) {
1570 rc = write(client->server_fd, &msg, sizeof(msg));
1581 DL_DELETE(client->streams, stream);
1592 static int client_thread_set_stream_volume(struct cras_client *client,
1598 stream = stream_from_id(client, stream_id);
1610 static int client_attach_shm(struct cras_client *client, int shm_fd)
1615 lock_rc = server_state_wrlock(client);
1616 if (client->server_state) {
1621 client->server_state = (struct cras_server_state *)mmap(
1622 NULL, sizeof(*client->server_state),
1626 if (client->server_state == (struct cras_server_state *)-1) {
1628 "cras_client: mmap failed to map shm for client: %s",
1633 if (client->server_state->state_version != CRAS_SERVER_STATE_VERSION) {
1634 munmap((void *)client->server_state,
1635 sizeof(*client->server_state));
1636 client->server_state = NULL;
1644 server_state_unlock(client, lock_rc);
1649 struct cras_client *client,
1652 if (!client->get_hotword_models_cb)
1654 client->get_hotword_models_cb(client, hotword_models);
1655 client->get_hotword_models_cb = NULL;
1659 static int handle_message_from_server(struct cras_client *client)
1669 nread = cras_recv_with_fds(client->server_fd, buf, sizeof(buf),
1680 rc = client_attach_shm(client, server_fds[0]);
1683 client->id = cmsg->client_id;
1691 stream_from_id(client, cmsg->stream_id);
1696 stream->config->err_cb(stream->client,
1703 if (client->debug_info_callback)
1704 client->debug_info_callback(client);
1709 cras_client_get_hotword_models_ready(client,
1716 if (client->observer_ops.output_volume_changed)
1717 client->observer_ops.output_volume_changed(
1718 client->observer_context,
1725 if (client->observer_ops.output_mute_changed)
1726 client->observer_ops.output_mute_changed(
1727 client->observer_context,
1736 if (client->observer_ops.capture_gain_changed)
1737 client->observer_ops.capture_gain_changed(
1738 client->observer_context,
1745 if (client->observer_ops.capture_mute_changed)
1746 client->observer_ops.capture_mute_changed(
1747 client->observer_context,
1753 if (client->observer_ops.nodes_changed)
1754 client->observer_ops.nodes_changed(
1755 client->observer_context);
1763 if (client->observer_ops.active_node_changed)
1764 client->observer_ops.active_node_changed(
1765 client->observer_context,
1772 if (client->observer_ops.output_node_volume_changed)
1773 client->observer_ops.output_node_volume_changed(
1774 client->observer_context,
1782 if (client->observer_ops.node_left_right_swapped_changed)
1783 client->observer_ops.node_left_right_swapped_changed(
1784 client->observer_context,
1792 if (client->observer_ops.input_node_gain_changed)
1793 client->observer_ops.input_node_gain_changed(
1794 client->observer_context,
1804 if (client->observer_ops.num_active_streams_changed)
1805 client->observer_ops.num_active_streams_changed(
1806 client->observer_context,
1817 /* Handles messages from streams to this client. */
1818 static int handle_stream_message(struct cras_client *client,
1827 rc = read(client->stream_fds[0], &msg, sizeof(msg));
1833 client_thread_rm_stream(client, msg.stream_id);
1837 /* Handles messages from users to this client. */
1838 static int handle_command_message(struct cras_client *client,
1848 rc = read(client->command_fds[0], buf, sizeof(msg->len));
1854 rc = read(client->command_fds[0], &buf[0] + rc, to_read);
1865 DL_FOREACH(client->streams, s)
1866 client_thread_rm_stream(client, s->id);
1868 /* And stop this client */
1869 client->thread.state = CRAS_THREAD_STOP;
1876 rc = client_thread_add_stream(client,
1883 rc = client_thread_rm_stream(client, msg->stream_id);
1888 rc = client_thread_set_stream_volume(client,
1894 rc = connect_to_server_wait(client, false);
1897 rc = server_connect(client);
1906 if (write(client->command_reply_fds[1], &rc, sizeof(rc)) != sizeof(rc))
1912 * The client program will call fucntions below to send messages to this thread
1917 struct cras_client *client = (struct cras_client *)arg;
1919 int (*cbs[4])(struct cras_client *client, int poll_revents);
1926 while (thread_is_running(&client->thread)) {
1929 rc = cras_file_wait_get_fd(client->sock_file_wait);
1939 if (client->server_fd >= 0) {
1941 server_fill_pollfd(client, &(pollfds[num_pollfds]));
1944 if (client->command_fds[0] >= 0) {
1946 pollfds[num_pollfds].fd = client->command_fds[0];
1951 if (client->stream_fds[0] >= 0) {
1953 pollfds[num_pollfds].fd = client->stream_fds[0];
1967 cbs[i](client, pollfds[i].revents);
1974 close(client->command_reply_fds[1]);
1975 client->command_reply_fds[1] = -1;
1980 /* Sends a message to the client thread to complete an action requested by the
1982 static int send_command_message(struct cras_client *client,
1986 if (client == NULL || !thread_is_running(&client->thread))
1989 rc = write(client->command_fds[1], msg, msg->len);
1994 rc = read(client->command_reply_fds[0], &cmd_res, sizeof(cmd_res));
2000 /* Send a simple message to the client thread that holds no data. */
2001 static int send_simple_cmd_msg(struct cras_client *client,
2011 return send_command_message(client, &msg);
2014 /* Sends the set volume message to the client thread. */
2015 static int send_stream_volume_command_msg(struct cras_client *client,
2026 return send_command_message(client, &msg.header);
2029 /* Sends a message back to the client and returns the error code. */
2030 static int write_message_to_server(struct cras_client *client,
2035 if (client->server_fd_state == CRAS_SOCKET_STATE_CONNECTED ||
2036 client->server_fd_state == CRAS_SOCKET_STATE_FIRST_MESSAGE) {
2037 write_rc = write(client->server_fd, msg, msg->length);
2043 client->server_fd_state != CRAS_SOCKET_STATE_FIRST_MESSAGE)
2055 * Exported Client Interface
2058 int cras_client_create(struct cras_client **client)
2076 *client = &client_int->client;
2077 (*client)->server_fd = -1;
2078 (*client)->id = -1;
2087 rc = pthread_mutex_init(&(*client)->stream_start_lock, NULL);
2096 rc = pthread_cond_init(&(*client)->stream_start_cond, &cond_attr);
2104 (*client)->server_event_fd = eventfd(0, EFD_CLOEXEC|EFD_NONBLOCK);
2105 if ((*client)->server_event_fd < 0) {
2112 (*client)->sock_file = (const char *)malloc(sock_file_size);
2113 if (!(*client)->sock_file) {
2117 snprintf((char *)(*client)->sock_file, sock_file_size, "%s/%s", sock_dir,
2120 rc = cras_file_wait_create((*client)->sock_file,
2122 sock_file_wait_callback, *client,
2123 &(*client)->sock_file_wait);
2126 (*client)->sock_file);
2129 (*client)->sock_file_exists = (rc == 0);
2131 /* Pipes used by the main thread and the client thread to send commands
2133 rc = pipe((*client)->command_fds);
2136 /* Pipe used to communicate between the client thread and the audio
2138 rc = pipe((*client)->stream_fds);
2140 close((*client)->command_fds[0]);
2141 close((*client)->command_fds[1]);
2144 (*client)->command_reply_fds[0] = -1;
2145 (*client)->command_reply_fds[1] = -1;
2149 if ((*client)->server_event_fd >= 0)
2150 close((*client)->server_event_fd);
2151 cras_file_wait_destroy((*client)->sock_file_wait);
2152 free((void *)(*client)->sock_file);
2154 pthread_cond_destroy(&(*client)->stream_start_cond);
2156 pthread_mutex_destroy(&(*client)->stream_start_lock);
2160 *client = NULL;
2165 void cras_client_destroy(struct cras_client *client)
2168 if (client == NULL)
2170 client_int = to_client_int(client);
2171 client->server_connection_cb = NULL;
2172 client->server_err_cb = NULL;
2173 cras_client_stop(client);
2174 server_disconnect(client);
2175 close(client->command_fds[0]);
2176 close(client->command_fds[1]);
2177 close(client->stream_fds[0]);
2178 close(client->stream_fds[1]);
2179 cras_file_wait_destroy(client->sock_file_wait);
2181 free((void *)client->sock_file);
2185 int cras_client_connect(struct cras_client *client)
2187 return connect_to_server(client, NULL, true);
2190 int cras_client_connect_timeout(struct cras_client *client,
2193 return connect_to_server_wait_retry(client, timeout_ms, true);
2196 int cras_client_connected_wait(struct cras_client *client)
2198 return send_simple_cmd_msg(client, 0, CLIENT_SERVER_CONNECT);
2201 int cras_client_connect_async(struct cras_client *client)
2203 return send_simple_cmd_msg(client, 0, CLIENT_SERVER_CONNECT_ASYNC);
2274 struct cras_client *client,
2283 if (client == NULL || config == NULL || stream_id_out == NULL)
2317 rc = send_command_message(client, &cmd_msg.header);
2335 int cras_client_add_stream(struct cras_client *client,
2340 client,
2346 int cras_client_add_pinned_stream(struct cras_client *client,
2352 client,
2358 int cras_client_rm_stream(struct cras_client *client,
2361 if (client == NULL)
2364 return send_simple_cmd_msg(client, stream_id, CLIENT_REMOVE_STREAM);
2367 int cras_client_set_stream_volume(struct cras_client *client,
2371 if (client == NULL)
2374 return send_stream_volume_command_msg(client, stream_id, volume_scaler);
2377 int cras_client_set_system_volume(struct cras_client *client, size_t volume)
2381 if (client == NULL)
2385 return write_message_to_server(client, &msg.header);
2388 int cras_client_set_system_capture_gain(struct cras_client *client, long gain)
2392 if (client == NULL)
2396 return write_message_to_server(client, &msg.header);
2399 int cras_client_set_system_mute(struct cras_client *client, int mute)
2403 if (client == NULL)
2407 return write_message_to_server(client, &msg.header);
2410 int cras_client_set_user_mute(struct cras_client *client, int mute)
2414 if (client == NULL)
2418 return write_message_to_server(client, &msg.header);
2421 int cras_client_set_system_mute_locked(struct cras_client *client, int locked)
2425 if (client == NULL)
2429 return write_message_to_server(client, &msg.header);
2432 int cras_client_set_system_capture_mute(struct cras_client *client, int mute)
2436 if (client == NULL)
2440 return write_message_to_server(client, &msg.header);
2443 int cras_client_set_system_capture_mute_locked(struct cras_client *client,
2448 if (client == NULL)
2452 return write_message_to_server(client, &msg.header);
2455 size_t cras_client_get_system_volume(const struct cras_client *client)
2460 lock_rc = server_state_rdlock(client);
2464 volume = client->server_state->volume;
2465 server_state_unlock(client, lock_rc);
2469 long cras_client_get_system_capture_gain(const struct cras_client *client)
2474 lock_rc = server_state_rdlock(client);
2478 gain = client->server_state->capture_gain;
2479 server_state_unlock(client, lock_rc);
2483 int cras_client_get_system_muted(const struct cras_client *client)
2488 lock_rc = server_state_rdlock(client);
2492 muted = client->server_state->mute;
2493 server_state_unlock(client, lock_rc);
2497 int cras_client_get_user_muted(const struct cras_client *client)
2502 lock_rc = server_state_rdlock(client);
2506 muted = client->server_state->user_mute;
2507 server_state_unlock(client, lock_rc);
2511 int cras_client_get_system_capture_muted(const struct cras_client *client)
2516 lock_rc = server_state_rdlock(client);
2520 muted = client->server_state->capture_mute;
2521 server_state_unlock(client, lock_rc);
2525 long cras_client_get_system_min_volume(const struct cras_client *client)
2530 lock_rc = server_state_rdlock(client);
2534 min_volume = client->server_state->min_volume_dBFS;
2535 server_state_unlock(client, lock_rc);
2539 long cras_client_get_system_max_volume(const struct cras_client *client)
2544 lock_rc = server_state_rdlock(client);
2548 max_volume = client->server_state->max_volume_dBFS;
2549 server_state_unlock(client, lock_rc);
2553 long cras_client_get_system_min_capture_gain(const struct cras_client *client)
2558 lock_rc = server_state_rdlock(client);
2562 min_gain = client->server_state->min_capture_gain;
2563 server_state_unlock(client, lock_rc);
2567 long cras_client_get_system_max_capture_gain(const struct cras_client *client)
2572 lock_rc = server_state_rdlock(client);
2576 max_gain = client->server_state->max_capture_gain;
2577 server_state_unlock(client, lock_rc);
2582 const struct cras_client *client)
2587 lock_rc = server_state_rdlock(client);
2591 debug_info = &client->server_state->audio_debug_info;
2592 server_state_unlock(client, lock_rc);
2596 unsigned cras_client_get_num_active_streams(const struct cras_client *client,
2602 lock_rc = server_state_rdlock(client);
2607 version = begin_server_state_read(client->server_state);
2610 num_streams += client->server_state->num_active_streams[i];
2616 &client->server_state->last_active_stream_time);
2618 if (end_server_state_read(client->server_state, version))
2621 server_state_unlock(client, lock_rc);
2625 int cras_client_run_thread(struct cras_client *client)
2629 if (client == NULL)
2631 if (thread_is_running(&client->thread))
2634 assert(client->command_reply_fds[0] == -1 &&
2635 client->command_reply_fds[1] == -1);
2637 if (pipe(client->command_reply_fds) < 0)
2639 client->thread.state = CRAS_THREAD_RUNNING;
2640 rc = pthread_create(&client->thread.tid, NULL, client_thread, client);
2642 client->thread.state = CRAS_THREAD_STOP;
2649 int cras_client_stop(struct cras_client *client)
2651 if (client == NULL)
2653 if (!thread_is_running(&client->thread))
2656 send_simple_cmd_msg(client, 0, CLIENT_STOP);
2657 pthread_join(client->thread.tid, NULL);
2659 /* The other end of the reply pipe is closed by the client thread, just
2661 close(client->command_reply_fds[0]);
2662 client->command_reply_fds[0] = -1;
2667 void cras_client_set_server_error_cb(struct cras_client *client,
2671 client->server_err_cb = err_cb;
2672 client->server_connection_user_arg = user_arg;
2676 struct cras_client *client,
2680 client->server_connection_cb = connection_cb;
2681 client->server_connection_user_arg = user_arg;
2684 void cras_client_set_thread_priority_cb(struct cras_client *client,
2687 client->thread_priority_cb = cb;
2690 int cras_client_get_output_devices(const struct cras_client *client,
2699 lock_rc = server_state_rdlock(client);
2702 state = client->server_state;
2712 server_state_unlock(client, lock_rc);
2720 int cras_client_get_input_devices(const struct cras_client *client,
2729 lock_rc = server_state_rdlock(client);
2730 if (!client)
2732 state = client->server_state;
2742 server_state_unlock(client, lock_rc);
2750 int cras_client_get_attached_clients(const struct cras_client *client,
2758 lock_rc = server_state_rdlock(client);
2761 state = client->server_state;
2769 server_state_unlock(client, lock_rc);
2784 static int cras_client_find_output_node(const struct cras_client *client,
2796 if (!client || !dev_name || !node_name)
2811 rc = cras_client_get_output_devices(client, devs, nodes, &ndevs,
2841 int cras_client_get_node_by_id(const struct cras_client *client,
2852 if (!client || !node_info) {
2874 rc = cras_client_get_input_devices(client, devs, nodes,
2877 rc = cras_client_get_output_devices(client, devs, nodes,
2898 int cras_client_output_dev_plugged(const struct cras_client *client,
2904 if (cras_client_find_output_node(client, name, "Front Headphone Jack",
2911 int cras_client_set_node_attr(struct cras_client *client,
2917 if (client == NULL)
2921 return write_message_to_server(client, &msg.header);
2924 int cras_client_select_node(struct cras_client *client,
2930 if (client == NULL)
2934 return write_message_to_server(client, &msg.header);
2937 int cras_client_add_active_node(struct cras_client *client,
2943 if (client == NULL)
2947 return write_message_to_server(client, &msg.header);
2950 int cras_client_rm_active_node(struct cras_client *client,
2956 if (client == NULL)
2960 return write_message_to_server(client, &msg.header);
3001 int cras_client_reload_dsp(struct cras_client *client)
3005 if (client == NULL)
3009 return write_message_to_server(client, &msg.header);
3012 int cras_client_dump_dsp_info(struct cras_client *client)
3016 if (client == NULL)
3020 return write_message_to_server(client, &msg.header);
3024 struct cras_client *client,
3029 if (client == NULL)
3032 client->debug_info_callback = debug_info_cb;
3035 return write_message_to_server(client, &msg.header);
3038 int cras_client_set_node_volume(struct cras_client *client,
3044 if (client == NULL)
3048 return write_message_to_server(client, &msg.header);
3051 int cras_client_swap_node_left_right(struct cras_client *client,
3056 if (client == NULL)
3061 return write_message_to_server(client, &msg.header);
3064 int cras_client_set_node_capture_gain(struct cras_client *client,
3070 if (client == NULL)
3076 return write_message_to_server(client, &msg.header);
3079 int cras_client_add_test_iodev(struct cras_client *client,
3085 return write_message_to_server(client, &msg.header);
3088 int cras_client_test_iodev_command(struct cras_client *client,
3099 rc = write_message_to_server(client, &msg->header);
3104 int cras_client_config_global_remix(struct cras_client *client,
3116 rc = write_message_to_server(client, &msg->header);
3122 int cras_client_get_first_dev_type_idx(const struct cras_client *client,
3133 lock_rc = server_state_rdlock(client);
3136 state = client->server_state;
3150 server_state_unlock(client, lock_rc);
3156 server_state_unlock(client, lock_rc);
3161 int cras_client_set_suspend(struct cras_client *client, int suspend)
3166 return write_message_to_server(client, &msg);
3169 int cras_client_get_hotword_models(struct cras_client *client,
3175 if (!client)
3177 client->get_hotword_models_cb = cb;
3180 return write_message_to_server(client, &msg.header);
3183 int cras_client_set_hotword_model(struct cras_client *client,
3190 return write_message_to_server(client, &msg.header);
3194 struct cras_client *client, void *context)
3196 if (!client)
3198 client->observer_context = context;
3201 static int cras_send_register_notification(struct cras_client *client,
3212 rc = write_message_to_server(client, &msg.header);
3219 struct cras_client *client,
3222 if (!client)
3224 client->observer_ops.output_volume_changed = cb;
3226 client, CRAS_CLIENT_OUTPUT_VOLUME_CHANGED, cb != NULL);
3230 struct cras_client *client,
3233 if (!client)
3235 client->observer_ops.output_mute_changed = cb;
3237 client, CRAS_CLIENT_OUTPUT_MUTE_CHANGED, cb != NULL);
3241 struct cras_client *client,
3244 if (!client)
3246 client->observer_ops.capture_gain_changed = cb;
3248 client, CRAS_CLIENT_CAPTURE_GAIN_CHANGED, cb != NULL);
3252 struct cras_client *client,
3255 if (!client)
3257 client->observer_ops.capture_mute_changed = cb;
3259 client, CRAS_CLIENT_CAPTURE_MUTE_CHANGED, cb != NULL);
3263 struct cras_client *client,
3266 if (!client)
3268 client->observer_ops.nodes_changed = cb;
3270 client, CRAS_CLIENT_NODES_CHANGED, cb != NULL);
3274 struct cras_client *client,
3277 if (!client)
3279 client->observer_ops.active_node_changed = cb;
3281 client, CRAS_CLIENT_ACTIVE_NODE_CHANGED, cb != NULL);
3285 struct cras_client *client,
3288 if (!client)
3290 client->observer_ops.output_node_volume_changed = cb;
3292 client, CRAS_CLIENT_OUTPUT_NODE_VOLUME_CHANGED, cb != NULL);
3296 struct cras_client *client,
3299 if (!client)
3301 client->observer_ops.node_left_right_swapped_changed = cb;
3303 client, CRAS_CLIENT_NODE_LEFT_RIGHT_SWAPPED_CHANGED, cb != NULL);
3307 struct cras_client *client,
3310 if (!client)
3312 client->observer_ops.input_node_gain_changed = cb;
3314 client, CRAS_CLIENT_INPUT_NODE_GAIN_CHANGED, cb != NULL);
3318 struct cras_client *client,
3321 if (!client)
3323 client->observer_ops.num_active_streams_changed = cb;
3325 client, CRAS_CLIENT_NUM_ACTIVE_STREAMS_CHANGED, cb != NULL);
3328 static int reregister_notifications(struct cras_client *client)
3332 if (client->observer_ops.output_volume_changed) {
3334 client,
3335 client->observer_ops.output_volume_changed);
3339 if (client->observer_ops.output_mute_changed) {
3341 client,
3342 client->observer_ops.output_mute_changed);
3346 if (client->observer_ops.capture_gain_changed) {
3348 client,
3349 client->observer_ops.capture_gain_changed);
3353 if (client->observer_ops.capture_mute_changed) {
3355 client,
3356 client->observer_ops.capture_mute_changed);
3360 if (client->observer_ops.nodes_changed) {
3362 client, client->observer_ops.nodes_changed);
3366 if (client->observer_ops.active_node_changed) {
3368 client,
3369 client->observer_ops.active_node_changed);
3373 if (client->observer_ops.output_node_volume_changed) {
3375 client,
3376 client->observer_ops.output_node_volume_changed);
3380 if (client->observer_ops.node_left_right_swapped_changed) {
3382 client,
3383 client->observer_ops.node_left_right_swapped_changed);
3387 if (client->observer_ops.input_node_gain_changed) {
3389 client,
3390 client->observer_ops.input_node_gain_changed);
3394 if (client->observer_ops.num_active_streams_changed) {
3396 client,
3397 client->observer_ops.num_active_streams_changed);
