Lines Matching refs:state
65 struct libasound_state *state = xfer->private_data;
68 err = snd_output_stdio_attach(&state->log, stderr, 0);
72 err = snd_pcm_hw_params_malloc(&state->hw_params);
76 return snd_pcm_sw_params_malloc(&state->sw_params);
82 struct libasound_state *state = xfer->private_data;
86 state->node_literal = arg_duplicate_string(optarg, &err);
88 state->nonblock = true;
90 state->mmap = true;
92 state->msec_per_period = arg_parse_decimal_num(optarg, &err);
94 state->msec_per_buffer = arg_parse_decimal_num(optarg, &err);
96 state->frames_per_period = arg_parse_decimal_num(optarg, &err);
98 state->frames_per_buffer = arg_parse_decimal_num(optarg, &err);
100 state->msec_for_avail_min = arg_parse_decimal_num(optarg, &err);
102 state->msec_for_start_threshold = arg_parse_decimal_num(optarg, &err);
104 state->msec_for_stop_threshold = arg_parse_decimal_num(optarg, &err);
106 state->waiter_type_literal = arg_duplicate_string(optarg, &err);
108 state->sched_model_literal = arg_duplicate_string(optarg, &err);
110 state->no_auto_resample = true;
112 state->no_auto_channels = true;
114 state->no_auto_format = true;
116 state->no_softvol = true;
122 state->finish_at_xrun = true;
124 state->test_nowait = true;
133 struct libasound_state *state = xfer->private_data;
136 state->verbose = xfer->verbose > 1;
138 if (state->node_literal == NULL) {
139 state->node_literal = strdup("default");
140 if (state->node_literal == NULL)
144 if (state->mmap && state->nonblock) {
151 if (state->test_nowait) {
152 if (!state->nonblock && !state->mmap) {
160 if (state->msec_per_period > 0 && state->msec_per_buffer > 0) {
161 if (state->msec_per_period > state->msec_per_buffer) {
162 state->msec_per_period = state->msec_per_buffer;
163 state->msec_per_buffer = 0;
167 if (state->frames_per_period > 0 && state->frames_per_buffer > 0) {
168 if (state->frames_per_period > state->frames_per_buffer) {
169 state->frames_per_period = state->frames_per_buffer;
170 state->frames_per_buffer = 0;
174 state->sched_model = SCHED_MODEL_IRQ;
175 if (state->sched_model_literal != NULL) {
176 if (!strcmp(state->sched_model_literal, "timer")) {
177 state->sched_model = SCHED_MODEL_TIMER;
178 state->mmap = true;
179 state->nonblock = true;
183 if (state->waiter_type_literal != NULL) {
184 if (state->test_nowait) {
190 if (!state->nonblock && !state->mmap) {
197 state->waiter_type =
198 waiter_type_from_label(state->waiter_type_literal);
200 state->waiter_type = WAITER_TYPE_DEFAULT;
206 static int set_access_hw_param(struct libasound_state *state)
215 if (state->mmap) {
222 err = snd_pcm_hw_params_set_access_mask(state->handle, state->hw_params,
229 static int disable_period_wakeup(struct libasound_state *state)
233 if (snd_pcm_type(state->handle) != SND_PCM_TYPE_HW) {
234 logging(state,
240 if (!snd_pcm_hw_params_can_disable_period_wakeup(state->hw_params)) {
241 logging(state,
248 err = snd_pcm_hw_params_set_period_wakeup(state->handle,
249 state->hw_params, 0);
251 logging(state,
262 struct libasound_state *state = xfer->private_data;
266 if (state->nonblock)
268 if (state->no_auto_resample)
270 if (state->no_auto_channels)
272 if (state->no_auto_format)
274 if (state->no_softvol)
277 err = snd_pcm_open(&state->handle, state->node_literal, xfer->direction,
280 logging(state, "Fail to open libasound PCM node for %s: %s\n",
282 state->node_literal);
286 if ((state->nonblock || state->mmap) && !state->test_nowait)
287 state->use_waiter = true;
289 err = snd_pcm_hw_params_any(state->handle, state->hw_params);
293 if (state->sched_model == SCHED_MODEL_TIMER) {
294 err = disable_period_wakeup(state);
300 logging(state, "Available HW Params of node: %s\n",
301 snd_pcm_name(state->handle));
302 snd_pcm_hw_params_dump(state->hw_params, state->log);
308 return set_access_hw_param(state);
311 static int prepare_waiter(struct libasound_state *state)
317 if (state->waiter_type == WAITER_TYPE_DEFAULT)
320 err = snd_pcm_poll_descriptors_count(state->handle);
327 state->waiter = malloc(sizeof(*state->waiter));
328 if (state->waiter == NULL)
331 err = waiter_context_init(state->waiter, state->waiter_type, pfd_count);
335 err = snd_pcm_poll_descriptors(state->handle, state->waiter->pfds,
340 return waiter_context_prepare(state->waiter);
343 int xfer_libasound_wait_event(struct libasound_state *state, int timeout_msec,
348 if (state->waiter_type != WAITER_TYPE_DEFAULT) {
349 struct waiter_context *waiter = state->waiter;
358 err = snd_pcm_poll_descriptors_revents(state->handle,
363 count = snd_pcm_wait(state->handle, timeout_msec);
369 if (snd_pcm_stream(state->handle) == SND_PCM_STREAM_PLAYBACK)
378 static int configure_hw_params(struct libasound_state *state,
396 snd_pcm_hw_params_get_format_mask(state->hw_params, mask);
403 logging(state,
408 err = snd_pcm_hw_params_set_format(state->handle, state->hw_params,
411 logging(state,
419 err = snd_pcm_hw_params_get_channels_min(state->hw_params,
422 logging(state,
427 err = snd_pcm_hw_params_set_channels(state->handle, state->hw_params,
430 logging(state,
438 err = snd_pcm_hw_params_get_rate_min(state->hw_params,
441 logging(state,
447 err = snd_pcm_hw_params_set_rate(state->handle, state->hw_params,
450 logging(state,
460 state->hw_params, &msec_per_buffer, NULL);
462 logging(state,
495 err = snd_pcm_hw_params_set_period_time_near(state->handle,
496 state->hw_params, &msec_per_period, NULL);
498 logging(state,
504 err = snd_pcm_hw_params_set_period_size_near(state->handle,
505 state->hw_params, &frames_per_period, NULL);
507 logging(state,
515 err = snd_pcm_hw_params_set_buffer_time_near(state->handle,
516 state->hw_params, &msec_per_buffer, NULL);
518 logging(state,
524 err = snd_pcm_hw_params_set_buffer_size_near(state->handle,
525 state->hw_params, &frames_per_buffer);
527 logging(state,
534 return snd_pcm_hw_params(state->handle, state->hw_params);
567 static int configure_sw_params(struct libasound_state *state,
580 logging(state,
588 err = snd_pcm_sw_params_set_avail_min(state->handle,
589 state->sw_params, frame_count);
591 logging(state,
601 logging(state,
609 err = snd_pcm_sw_params_set_start_threshold(state->handle,
610 state->sw_params, frame_count);
612 logging(state,
622 logging(state,
630 err = snd_pcm_sw_params_set_stop_threshold(state->handle,
631 state->sw_params, frame_count);
633 logging(state,
639 return snd_pcm_sw_params(state->handle, state->sw_params);
649 struct libasound_state *state = xfer->private_data;
657 err = configure_hw_params(state, *format, *samples_per_frame,
659 state->msec_per_period,
660 state->msec_per_buffer,
661 state->frames_per_period,
662 state->frames_per_buffer);
664 logging(state, "Current hardware parameters:\n");
665 snd_pcm_hw_params_dump(state->hw_params, state->log);
670 err = retrieve_actual_hw_params(state->hw_params, format,
677 err = snd_pcm_sw_params_current(state->handle, state->sw_params);
682 err = snd_pcm_hw_params_get_period_wakeup(state->handle,
683 state->hw_params, &flag);
690 state->ops = &xfer_libasound_irq_rw_ops;
693 if (snd_pcm_stream(state->handle) == SND_PCM_STREAM_CAPTURE)
694 state->ops = &xfer_libasound_irq_mmap_r_ops;
696 state->ops = &xfer_libasound_irq_mmap_w_ops;
703 if (snd_pcm_stream(state->handle) == SND_PCM_STREAM_CAPTURE)
704 state->ops = &xfer_libasound_timer_mmap_r_ops;
706 state->ops = &xfer_libasound_timer_mmap_w_ops;
712 if (state->ops->private_size > 0) {
713 state->private_data = malloc(state->ops->private_size);
714 if (state->private_data == NULL)
716 memset(state->private_data, 0, state->ops->private_size);
719 err = state->ops->pre_process(state);
723 err = configure_sw_params(state, *frames_per_second,
725 state->msec_for_avail_min,
726 state->msec_for_start_threshold,
727 state->msec_for_stop_threshold);
729 logging(state, "Current software parameters:\n");
730 snd_pcm_sw_params_dump(state->sw_params, state->log);
735 snd_pcm_dump(state->handle, state->log);
736 logging(state, "Scheduling model:\n");
737 logging(state, " %s\n", sched_model_labels[state->sched_model]);
740 if (state->use_waiter) {
743 err = prepare_waiter(state);
748 logging(state, "Waiter type:\n");
749 logging(state,
751 waiter_label_from_type(state->waiter_type));
763 struct libasound_state *state = xfer->private_data;
766 if (state->handle == NULL)
769 err = state->ops->process_frames(state, frame_count, mapper, cntrs);
773 if (err == -EPIPE && !state->finish_at_xrun) {
777 err = snd_pcm_prepare(state->handle);
784 logging(state, "Fail to process frames: %s\n",
794 struct libasound_state *state = xfer->private_data;
795 snd_pcm_state_t s = snd_pcm_state(state->handle);
798 if (state->handle == NULL)
809 // Not supported. Leave the substream to enter XRUN state.
810 if (!snd_pcm_hw_params_can_pause(state->hw_params))
813 err = snd_pcm_pause(state->handle, enable);
814 if (err < 0 && state->verbose) {
815 logging(state, "snd_pcm_pause(): %s\n", snd_strerror(err));
821 struct libasound_state *state = xfer->private_data;
825 if (state->handle == NULL)
828 pcm_state = snd_pcm_state(state->handle);
831 if (snd_pcm_stream(state->handle) == SND_PCM_STREAM_CAPTURE ||
832 state->ops == &xfer_libasound_timer_mmap_w_ops) {
833 err = snd_pcm_drop(state->handle);
835 logging(state, "snd_pcm_drop(): %s\n",
839 if (state->nonblock)
840 snd_pcm_nonblock(state->handle, 0);
841 err = snd_pcm_drain(state->handle);
842 if (state->nonblock)
843 snd_pcm_nonblock(state->handle, 1);
845 logging(state, "snd_pcm_drain(): %s\n",
850 err = snd_pcm_hw_free(state->handle);
852 logging(state, "snd_pcm_hw_free(): %s\n", snd_strerror(err));
854 snd_pcm_close(state->handle);
855 state->handle = NULL;
857 if (state->ops && state->ops->post_process)
858 state->ops->post_process(state);
859 free(state->private_data);
860 state->private_data = NULL;
869 struct libasound_state *state = xfer->private_data;
871 free(state->node_literal);
872 free(state->waiter_type_literal);
873 free(state->sched_model_literal);
874 state->node_literal = NULL;
875 state->waiter_type_literal = NULL;
876 state->sched_model_literal = NULL;
878 if (state->hw_params)
879 snd_pcm_hw_params_free(state->hw_params);
880 if (state->sw_params)
881 snd_pcm_sw_params_free(state->sw_params);
882 state->hw_params = NULL;
883 state->sw_params = NULL;
885 if (state->log)
886 snd_output_close(state->log);
887 state->log = NULL;