Lines Matching defs:out
1112 struct stream_out *out = adev->primary_output;
1120 if (out != NULL && out->usecase == USECASE_AUDIO_PLAYBACK) {
1125 if ((out->echo_reference_generation != prev_generation) || out->standby)
1214 static int get_playback_delay(struct stream_out *out,
1223 pcm_device = node_to_item(list_head(&out->pcm_dev_list),
1242 out->config.rate);
2095 /* must be called with out->lock locked */
2096 static int send_offload_cmd_l(struct stream_out* out, int command)
2103 list_add_tail(&out->offload_cmd_list, &cmd->node);
2104 pthread_cond_signal(&out->offload_cond);
2108 /* must be called iwth out->lock locked */
2109 static void stop_compressed_output_l(struct stream_out *out)
2111 out->offload_state = OFFLOAD_STATE_IDLE;
2112 out->playback_started = 0;
2113 out->send_new_metadata = 1;
2114 if (out->compr != NULL) {
2115 compress_stop(out->compr);
2116 while (out->offload_thread_blocked) {
2117 pthread_cond_wait(&out->cond, &out->lock);
2124 struct stream_out *out = (struct stream_out *) context;
2127 out->offload_state = OFFLOAD_STATE_IDLE;
2128 out->playback_started = 0;
2135 pthread_mutex_lock(&out->lock);
2141 ALOGVV("%s offload_cmd_list %d out->offload_state %d",
2142 __func__, list_empty(&out->offload_cmd_list),
2143 out->offload_state);
2144 if (list_empty(&out->offload_cmd_list)) {
2146 pthread_cond_wait(&out->offload_cond, &out->lock);
2151 item = list_head(&out->offload_cmd_list);
2155 ALOGVV("%s STATE %d CMD %d out->compr %p",
2156 __func__, out->offload_state, cmd->cmd, out->compr);
2163 if (out->compr == NULL) {
2165 pthread_cond_signal(&out->cond);
2168 out->offload_thread_blocked = true;
2169 pthread_mutex_unlock(&out->lock);
2173 compress_wait(out->compr, -1);
2178 compress_next_track(out->compr);
2179 compress_partial_drain(out->compr);
2184 out->compr);
2192 pthread_mutex_lock(&out->lock);
2193 out->offload_thread_blocked = false;
2194 pthread_cond_signal(&out->cond);
2196 out->offload_callback(event, NULL, out->offload_cookie);
2201 pthread_cond_signal(&out->cond);
2202 while (!list_empty(&out->offload_cmd_list)) {
2203 item = list_head(&out->offload_cmd_list);
2207 pthread_mutex_unlock(&out->lock);
2212 static int create_offload_callback_thread(struct stream_out *out)
2214 pthread_cond_init(&out->offload_cond, (const pthread_condattr_t *) NULL);
2215 list_init(&out->offload_cmd_list);
2216 pthread_create(&out->offload_thread, (const pthread_attr_t *) NULL,
2217 offload_thread_loop, out);
2221 static int destroy_offload_callback_thread(struct stream_out *out)
2223 pthread_mutex_lock(&out->lock);
2224 stop_compressed_output_l(out);
2225 send_offload_cmd_l(out, OFFLOAD_CMD_EXIT);
2227 pthread_mutex_unlock(&out->lock);
2228 pthread_join(out->offload_thread, (void **) NULL);
2229 pthread_cond_destroy(&out->offload_cond);
2236 struct stream_out *out = (struct stream_out *)usecase->stream;
2241 list_for_each_safe(node, next, &out->pcm_dev_list) {
2254 struct stream_out *out = (struct stream_out *)usecase->stream;
2261 list_init(&out->pcm_dev_list);
2266 list_add_tail(&out->pcm_dev_list, &pcm_device->stream_list_node);
2269 mixer_card = adev_get_mixer_for_card(out->dev, pcm_profile->card);
2278 static int out_close_pcm_devices(struct stream_out *out)
2282 struct audio_device *adev = out->dev;
2284 list_for_each(node, &out->pcm_dev_list) {
2307 static int out_open_pcm_devices(struct stream_out *out)
2313 list_for_each(node, &out->pcm_dev_list) {
2331 if (out->sample_rate != pcm_device->pcm_profile->config.rate) {
2335 out->sample_rate, pcm_device->pcm_profile->config.rate);
2336 ret = create_resampler(out->sample_rate,
2338 audio_channel_count_from_out_mask(out->channel_mask),
2349 out_close_pcm_devices(out);
2353 static int stop_output_stream(struct stream_out *out)
2357 struct audio_device *adev = out->dev;
2360 out->usecase, use_case_table[out->usecase]);
2361 uc_info = get_usecase_from_id(adev, out->usecase);
2364 __func__, out->usecase);
2368 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD &&
2370 adev->offload_fx_stop_output(out->handle);
2382 int start_output_stream(struct stream_out *out)
2386 struct audio_device *adev = out->dev;
2389 __func__, out->usecase, use_case_table[out->usecase], out->devices, out->config.channels);
2392 uc_info->id = out->usecase;
2394 uc_info->stream = (struct audio_stream *)out;
2395 uc_info->devices = out->devices;
2402 select_devices(adev, out->usecase);
2404 if (out->usecase != USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2405 out->compr = NULL;
2406 ret = out_open_pcm_devices(out);
2410 out->echo_reference = NULL;
2411 out->echo_reference_generation = adev->echo_reference_generation;
2413 out->echo_reference = adev->echo_reference;
2416 out->compr = compress_open(COMPRESS_CARD, COMPRESS_DEVICE,
2417 COMPRESS_IN, &out->compr_config);
2418 if (out->compr && !is_compress_ready(out->compr)) {
2419 ALOGE("%s: %s", __func__, compress_get_error(out->compr));
2420 compress_close(out->compr);
2421 out->compr = NULL;
2425 if (out->offload_callback)
2426 compress_nonblock(out->compr, out->non_blocking);
2429 adev->offload_fx_start_output(out->handle);
2434 stop_output_stream(out);
2553 struct stream_out *out = (struct stream_out *)stream;
2555 return out->sample_rate;
2567 struct stream_out *out = (struct stream_out *)stream;
2569 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2570 return out->compr_config.fragment_size;
2573 return out->config.period_size *
2579 struct stream_out *out = (struct stream_out *)stream;
2581 return out->channel_mask;
2586 struct stream_out *out = (struct stream_out *)stream;
2588 return out->format;
2598 static int do_out_standby_l(struct stream_out *out)
2600 struct audio_device *adev = out->dev;
2603 out->standby = true;
2604 if (out->usecase != USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2605 out_close_pcm_devices(out);
2608 if (out->echo_reference != NULL) {
2609 out->echo_reference->write(out->echo_reference, NULL);
2610 if (out->echo_reference_generation != adev->echo_reference_generation) {
2611 ALOGV("%s: release_echo_reference %p", __func__, out->echo_reference);
2612 release_echo_reference(out->echo_reference);
2613 out->echo_reference_generation = adev->echo_reference_generation;
2615 out->echo_reference = NULL;
2619 stop_compressed_output_l(out);
2620 out->gapless_mdata.encoder_delay = 0;
2621 out->gapless_mdata.encoder_padding = 0;
2622 if (out->compr != NULL) {
2623 compress_close(out->compr);
2624 out->compr = NULL;
2627 status = stop_output_stream(out);
2634 struct stream_out *out = (struct stream_out *)stream;
2635 struct audio_device *adev = out->dev;
2638 out->usecase, use_case_table[out->usecase]);
2639 pthread_mutex_lock(&out->lock);
2640 if (!out->standby) {
2642 do_out_standby_l(out);
2645 pthread_mutex_unlock(&out->lock);
2658 static int parse_compress_metadata(struct stream_out *out, struct str_parms *parms)
2664 if (!out || !parms) {
2682 out->gapless_mdata = tmp_mdata;
2683 out->send_new_metadata = 1;
2685 out->gapless_mdata.encoder_delay, out->gapless_mdata.encoder_padding);
2693 struct stream_out *out = (struct stream_out *)stream;
2694 struct audio_device *adev = out->dev;
2708 ALOGD("%s: enter: usecase(%d: %s) kvpairs: %s out->devices(%d) adev->mode(%d)",
2709 __func__, out->usecase, use_case_table[out->usecase], kvpairs, out->devices, adev->mode);
2715 pthread_mutex_lock(&out->lock);
2718 if (((int)out->devices != val) && (val != 0) && (!out->standby) &&
2719 (out->usecase == USECASE_AUDIO_PLAYBACK)) {
2730 out->devices = val;
2732 if (!out->standby) {
2733 uc_info = get_usecase_from_id(adev, out->usecase);
2736 __func__, out->usecase);
2738 list_for_each(node, &out->pcm_dev_list) {
2748 do_out_standby_l(out);
2750 select_devices(adev, out->usecase);
2754 (out == adev->primary_output)) {
2757 (out == adev->primary_output)) {
2763 (out == adev->primary_output)) {
2767 pthread_mutex_unlock(&out->lock);
2782 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2783 parse_compress_metadata(out, parms);
2793 struct stream_out *out = (struct stream_out *)stream;
2806 while (out->supported_channel_masks[i] != 0) {
2808 if (out_channels_name_to_enum_table[j].value == out->supported_channel_masks[i]) {
2832 struct stream_out *out = (struct stream_out *)stream;
2834 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD)
2837 return (out->config.period_count * out->config.period_size * 1000) /
2838 (out->config.rate);
2844 struct stream_out *out = (struct stream_out *)stream;
2847 if (out->usecase == USECASE_AUDIO_PLAYBACK_MULTI_CH) {
2849 out->muted = (left == 0.0f);
2851 } else if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2881 struct stream_out *out = (struct stream_out *)stream;
2882 struct audio_device *adev = out->dev;
2895 pthread_mutex_lock(&out->lock);
2896 if (out->standby) {
2898 pthread_mutex_unlock(&out->lock);
2901 pthread_mutex_lock(&out->lock);
2902 if (!out->standby) {
2908 ret = start_output_stream(out);
2917 out->standby = false;
2938 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2940 if (out->send_new_metadata) {
2942 compress_set_gapless_metadata(out->compr, &out->gapless_mdata);
2943 out->send_new_metadata = 0;
2946 ret = compress_write(out->compr, buffer, bytes);
2949 send_offload_cmd_l(out, OFFLOAD_CMD_WAIT_FOR_BUFFER);
2951 if (!out->playback_started) {
2952 compress_start(out->compr);
2953 out->playback_started = 1;
2954 out->offload_state = OFFLOAD_STATE_PLAYING;
2956 pthread_mutex_unlock(&out->lock);
2967 != out->echo_reference_generation) {
2969 if (out->echo_reference != NULL) {
2970 ALOGV("%s: release_echo_reference %p", __func__, out->echo_reference);
2971 release_echo_reference(out->echo_reference);
2976 out->echo_reference_generation = adev->echo_reference_generation;
2977 out->echo_reference = adev->echo_reference;
2979 out->echo_reference_generation);
2984 if (out->muted)
2986 list_for_each(node, &out->pcm_dev_list) {
2989 if (bytes * pcm_device->pcm_profile->config.rate / out->sample_rate + frame_size
2992 bytes * pcm_device->pcm_profile->config.rate / out->sample_rate + frame_size;
3008 if (out->echo_reference != NULL && pcm_device->pcm_profile->devices != SND_DEVICE_OUT_SPEAKER) {
3013 get_playback_delay(out, out_frames, &b);
3014 out->echo_reference->write(out->echo_reference, &b);
3017 if (out->devices & AUDIO_DEVICE_OUT_SPEAKER) {
3021 calloc(pcm_frames_to_bytes(pcm_device->pcm, out->config.period_size),
3025 for (i = out->config.period_count; i > 0; i--)
3027 pcm_frames_to_bytes(pcm_device->pcm, out->config.period_size));
3054 out->written += bytes / (out->config.channels * sizeof(short));
3058 pthread_mutex_unlock(&out->lock);
3061 list_for_each(node, &out->pcm_dev_list) {
3066 out_standby(&out->stream.common);
3068 out_get_sample_rate(&out->stream.common));
3091 struct stream_out *out = (struct stream_out *)stream;
3093 if ((out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) && (dsp_frames != NULL)) {
3094 pthread_mutex_lock(&out->lock);
3095 if (out->compr != NULL) {
3096 compress_get_tstamp(out->compr, (unsigned long *)dsp_frames,
3097 &out->sample_rate);
3099 __func__, *dsp_frames, out->sample_rate);
3101 pthread_mutex_unlock(&out->lock);
3132 out = (struct stream_out *)stream;
3136 pthread_mutex_lock(&out->lock);
3138 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
3139 if (out->compr != NULL) {
3140 compress_get_tstamp(out->compr, &dsp_frames,
3141 &out->sample_rate);
3143 __func__, dsp_frames, out->sample_rate);
3151 if (!list_empty(&out->pcm_dev_list)) {
3153 struct pcm_device *pcm_device = node_to_item(list_head(&out->pcm_dev_list),
3157 size_t kernel_buffer_size = out->config.period_size * out->config.period_count;
3158 int64_t signed_frames = out->written - kernel_buffer_size + avail;
3162 (render_latency(out->usecase) * out->sample_rate / 1000000LL);
3173 pthread_mutex_unlock(&out->lock);
3181 struct stream_out *out = (struct stream_out *)stream;
3184 pthread_mutex_lock(&out->lock);
3185 out->offload_callback = callback;
3186 out->offload_cookie = cookie;
3187 pthread_mutex_unlock(&out->lock);
3193 struct stream_out *out = (struct stream_out *)stream;
3196 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
3197 pthread_mutex_lock(&out->lock);
3198 if (out->compr != NULL && out->offload_state == OFFLOAD_STATE_PLAYING) {
3199 status = compress_pause(out->compr);
3200 out->offload_state = OFFLOAD_STATE_PAUSED;
3202 pthread_mutex_unlock(&out->lock);
3209 struct stream_out *out = (struct stream_out *)stream;
3212 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
3214 pthread_mutex_lock(&out->lock);
3215 if (out->compr != NULL && out->offload_state == OFFLOAD_STATE_PAUSED) {
3216 status = compress_resume(out->compr);
3217 out->offload_state = OFFLOAD_STATE_PLAYING;
3219 pthread_mutex_unlock(&out->lock);
3226 struct stream_out *out = (struct stream_out *)stream;
3229 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
3230 pthread_mutex_lock(&out->lock);
3232 status = send_offload_cmd_l(out, OFFLOAD_CMD_PARTIAL_DRAIN);
3234 status = send_offload_cmd_l(out, OFFLOAD_CMD_DRAIN);
3235 pthread_mutex_unlock(&out->lock);
3242 struct stream_out *out = (struct stream_out *)stream;
3244 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
3245 pthread_mutex_lock(&out->lock);
3246 stop_compressed_output_l(out);
3247 pthread_mutex_unlock(&out->lock);
3691 struct stream_out *out;
3698 out = (struct stream_out *)calloc(1, sizeof(struct stream_out));
3703 out->flags = flags;
3704 out->devices = devices;
3705 out->dev = adev;
3706 out->format = config->format;
3707 out->sample_rate = config->sample_rate;
3708 out->channel_mask = AUDIO_CHANNEL_OUT_STEREO;
3709 out->supported_channel_masks[0] = AUDIO_CHANNEL_OUT_STEREO;
3710 out->handle = handle;
3717 out->config = pcm_profile->config;
3720 if (out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) {
3733 out->compr_config.codec = (struct snd_codec *)
3736 out->usecase = USECASE_AUDIO_PLAYBACK_OFFLOAD;
3738 out->channel_mask = config->offload_info.channel_mask;
3740 out->channel_mask = config->channel_mask;
3741 out->format = config->offload_info.format;
3742 out->sample_rate = config->offload_info.sample_rate;
3744 out->stream.set_callback = out_set_callback;
3745 out->stream.pause = out_pause;
3746 out->stream.resume = out_resume;
3747 out->stream.drain = out_drain;
3748 out->stream.flush = out_flush;
3750 out->compr_config.codec->id =
3752 out->compr_config.fragment_size = COMPRESS_OFFLOAD_FRAGMENT_SIZE;
3753 out->compr_config.fragments = COMPRESS_OFFLOAD_NUM_FRAGMENTS;
3754 out->compr_config.codec->sample_rate =
3756 out->compr_config.codec->bit_rate =
3758 out->compr_config.codec->ch_in =
3760 out->compr_config.codec->ch_out = out->compr_config.codec->ch_in;
3763 out->non_blocking = 1;
3765 out->send_new_metadata = 1;
3766 create_offload_callback_thread(out);
3770 } else if (out->flags & (AUDIO_OUTPUT_FLAG_DEEP_BUFFER)) {
3771 out->usecase = USECASE_AUDIO_PLAYBACK_DEEP_BUFFER;
3772 out->config = pcm_config_deep_buffer;
3773 out->sample_rate = out->config.rate;
3776 out->usecase = USECASE_AUDIO_PLAYBACK;
3777 out->sample_rate = out->config.rate;
3782 adev->primary_output = out;
3792 if (get_usecase_from_id(adev, out->usecase) != NULL) {
3793 ALOGE("%s: Usecase (%d) is already present", __func__, out->usecase);
3800 out->stream.common.get_sample_rate = out_get_sample_rate;
3801 out->stream.common.set_sample_rate = out_set_sample_rate;
3802 out->stream.common.get_buffer_size = out_get_buffer_size;
3803 out->stream.common.get_channels = out_get_channels;
3804 out->stream.common.get_format = out_get_format;
3805 out->stream.common.set_format = out_set_format;
3806 out->stream.common.standby = out_standby;
3807 out->stream.common.dump = out_dump;
3808 out->stream.common.set_parameters = out_set_parameters;
3809 out->stream.common.get_parameters = out_get_parameters;
3810 out->stream.common.add_audio_effect = out_add_audio_effect;
3811 out->stream.common.remove_audio_effect = out_remove_audio_effect;
3812 out->stream.get_latency = out_get_latency;
3813 out->stream.set_volume = out_set_volume;
3814 out->stream.write = out_write;
3815 out->stream.get_render_position = out_get_render_position;
3816 out->stream.get_next_write_timestamp = out_get_next_write_timestamp;
3817 out->stream.get_presentation_position = out_get_presentation_position;
3819 out->standby = 1;
3820 /* out->muted = false; by calloc() */
3821 /* out->written = 0; by calloc() */
3823 pthread_mutex_init(&out->lock, (const pthread_mutexattr_t *) NULL);
3824 pthread_cond_init(&out->cond, (const pthread_condattr_t *) NULL);
3826 config->format = out->stream.common.get_format(&out->stream.common);
3827 config->channel_mask = out->stream.common.get_channels(&out->stream.common);
3828 config->sample_rate = out->stream.common.get_sample_rate(&out->stream.common);
3830 *stream_out = &out->stream;
3835 free(out);
3844 struct stream_out *out = (struct stream_out *)stream;
3845 struct audio_device *adev = out->dev;
3850 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
3851 destroy_offload_callback_thread(out);
3853 if (out->compr_config.codec != NULL)
3854 free(out->compr_config.codec);
3856 pthread_cond_destroy(&out->cond);
3857 pthread_mutex_destroy(&out->lock);
