Lines Matching defs:out
1114 struct stream_out *out = adev->primary_output;
1122 if (out != NULL && out->usecase == USECASE_AUDIO_PLAYBACK) {
1127 if ((out->echo_reference_generation != prev_generation) || out->standby)
1216 static int get_playback_delay(struct stream_out *out,
1225 pcm_device = node_to_item(list_head(&out->pcm_dev_list),
1244 out->config.rate);
2097 /* must be called with out->lock locked */
2098 static int send_offload_cmd_l(struct stream_out* out, int command)
2105 list_add_tail(&out->offload_cmd_list, &cmd->node);
2106 pthread_cond_signal(&out->offload_cond);
2110 /* must be called iwth out->lock locked */
2111 static void stop_compressed_output_l(struct stream_out *out)
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;
2132 pthread_mutex_lock(&out->lock);
2138 ALOGVV("%s offload_cmd_list %d out->offload_state %d",
2139 __func__, list_empty(&out->offload_cmd_list),
2140 out->offload_state);
2141 if (list_empty(&out->offload_cmd_list)) {
2143 pthread_cond_wait(&out->offload_cond, &out->lock);
2148 item = list_head(&out->offload_cmd_list);
2152 ALOGVV("%s STATE %d CMD %d out->compr %p",
2153 __func__, out->offload_state, cmd->cmd, out->compr);
2160 if (out->compr == NULL) {
2162 pthread_cond_signal(&out->cond);
2165 out->offload_thread_blocked = true;
2166 pthread_mutex_unlock(&out->lock);
2170 compress_wait(out->compr, -1);
2175 compress_next_track(out->compr);
2176 compress_partial_drain(out->compr);
2181 compress_drain(out->compr);
2189 pthread_mutex_lock(&out->lock);
2190 out->offload_thread_blocked = false;
2191 pthread_cond_signal(&out->cond);
2193 out->offload_callback(event, NULL, out->offload_cookie);
2198 pthread_cond_signal(&out->cond);
2199 while (!list_empty(&out->offload_cmd_list)) {
2200 item = list_head(&out->offload_cmd_list);
2204 pthread_mutex_unlock(&out->lock);
2209 static int create_offload_callback_thread(struct stream_out *out)
2211 pthread_cond_init(&out->offload_cond, (const pthread_condattr_t *) NULL);
2212 list_init(&out->offload_cmd_list);
2213 pthread_create(&out->offload_thread, (const pthread_attr_t *) NULL,
2214 offload_thread_loop, out);
2218 static int destroy_offload_callback_thread(struct stream_out *out)
2220 pthread_mutex_lock(&out->lock);
2221 send_offload_cmd_l(out, OFFLOAD_CMD_EXIT);
2223 pthread_mutex_unlock(&out->lock);
2224 pthread_join(out->offload_thread, (void **) NULL);
2225 pthread_cond_destroy(&out->offload_cond);
2232 struct stream_out *out = (struct stream_out *)usecase->stream;
2237 list_for_each_safe(node, next, &out->pcm_dev_list) {
2250 struct stream_out *out = (struct stream_out *)usecase->stream;
2257 list_init(&out->pcm_dev_list);
2262 list_add_tail(&out->pcm_dev_list, &pcm_device->stream_list_node);
2265 mixer_card = adev_get_mixer_for_card(out->dev, pcm_profile->card);
2274 static int out_close_pcm_devices(struct stream_out *out)
2278 struct audio_device *adev = out->dev;
2280 list_for_each(node, &out->pcm_dev_list) {
2303 static int out_open_pcm_devices(struct stream_out *out)
2309 list_for_each(node, &out->pcm_dev_list) {
2327 if (out->sample_rate != pcm_device->pcm_profile->config.rate) {
2331 out->sample_rate, pcm_device->pcm_profile->config.rate);
2332 ret = create_resampler(out->sample_rate,
2334 audio_channel_count_from_out_mask(out->channel_mask),
2345 out_close_pcm_devices(out);
2349 static int disable_output_path_l(struct stream_out *out)
2351 struct audio_device *adev = out->dev;
2354 uc_info = get_usecase_from_id(adev, out->usecase);
2357 __func__, out->usecase);
2368 static void enable_output_path_l(struct stream_out *out)
2370 struct audio_device *adev = out->dev;
2374 uc_info->id = out->usecase;
2376 uc_info->stream = (struct audio_stream *)out;
2377 uc_info->devices = out->devices;
2384 select_devices(adev, out->usecase);
2387 static int stop_output_stream(struct stream_out *out)
2390 struct audio_device *adev = out->dev;
2394 out->usecase, use_case_table[out->usecase]);
2396 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD &&
2398 adev->offload_fx_stop_output(out->handle);
2400 if (out->offload_state == OFFLOAD_STATE_PAUSED ||
2401 out->offload_state == OFFLOAD_STATE_PAUSED_FLUSHED)
2403 out->offload_state = OFFLOAD_STATE_IDLE;
2406 ret = disable_output_path_l(out);
2412 int start_output_stream(struct stream_out *out)
2415 struct audio_device *adev = out->dev;
2418 __func__, out->usecase, use_case_table[out->usecase], out->devices, out->config.channels);
2420 enable_output_path_l(out);
2422 if (out->usecase != USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2423 out->compr = NULL;
2424 ret = out_open_pcm_devices(out);
2428 out->echo_reference = NULL;
2429 out->echo_reference_generation = adev->echo_reference_generation;
2431 out->echo_reference = adev->echo_reference;
2434 out->compr = compress_open(COMPRESS_CARD, COMPRESS_DEVICE,
2435 COMPRESS_IN, &out->compr_config);
2436 if (out->compr && !is_compress_ready(out->compr)) {
2437 ALOGE("%s: %s", __func__, compress_get_error(out->compr));
2438 compress_close(out->compr);
2439 out->compr = NULL;
2443 if (out->offload_callback)
2444 compress_nonblock(out->compr, out->non_blocking);
2447 adev->offload_fx_start_output(out->handle);
2452 stop_output_stream(out);
2571 struct stream_out *out = (struct stream_out *)stream;
2573 return out->sample_rate;
2585 struct stream_out *out = (struct stream_out *)stream;
2587 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2588 return out->compr_config.fragment_size;
2591 return out->config.period_size *
2597 struct stream_out *out = (struct stream_out *)stream;
2599 return out->channel_mask;
2604 struct stream_out *out = (struct stream_out *)stream;
2606 return out->format;
2616 static int do_out_standby_l(struct stream_out *out)
2618 struct audio_device *adev = out->dev;
2621 out->standby = true;
2622 if (out->usecase != USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2623 out_close_pcm_devices(out);
2626 if (out->echo_reference != NULL) {
2627 out->echo_reference->write(out->echo_reference, NULL);
2628 if (out->echo_reference_generation != adev->echo_reference_generation) {
2629 ALOGV("%s: release_echo_reference %p", __func__, out->echo_reference);
2630 release_echo_reference(out->echo_reference);
2631 out->echo_reference_generation = adev->echo_reference_generation;
2633 out->echo_reference = NULL;
2637 stop_compressed_output_l(out);
2638 out->gapless_mdata.encoder_delay = 0;
2639 out->gapless_mdata.encoder_padding = 0;
2640 if (out->compr != NULL) {
2641 compress_close(out->compr);
2642 out->compr = NULL;
2645 status = stop_output_stream(out);
2652 struct stream_out *out = (struct stream_out *)stream;
2653 struct audio_device *adev = out->dev;
2656 out->usecase, use_case_table[out->usecase]);
2657 pthread_mutex_lock(&out->lock);
2658 if (!out->standby) {
2660 do_out_standby_l(out);
2663 pthread_mutex_unlock(&out->lock);
2676 static int parse_compress_metadata(struct stream_out *out, struct str_parms *parms)
2682 if (!out || !parms) {
2700 out->gapless_mdata = tmp_mdata;
2701 out->send_new_metadata = 1;
2703 out->gapless_mdata.encoder_delay, out->gapless_mdata.encoder_padding);
2711 struct stream_out *out = (struct stream_out *)stream;
2712 struct audio_device *adev = out->dev;
2726 ALOGD("%s: enter: usecase(%d: %s) kvpairs: %s out
2727 __func__, out->usecase, use_case_table[out->usecase], kvpairs, out->devices, adev->mode);
2733 pthread_mutex_lock(&out->lock);
2736 if (((int)out->devices != val) && (val != 0) && (!out->standby) &&
2737 (out->usecase == USECASE_AUDIO_PLAYBACK)) {
2748 out->devices = val;
2750 if (!out->standby) {
2751 uc_info = get_usecase_from_id(adev, out->usecase);
2754 __func__, out->usecase);
2756 list_for_each(node, &out->pcm_dev_list) {
2766 do_out_standby_l(out);
2768 select_devices(adev, out->usecase);
2772 (out == adev->primary_output)) {
2775 (out == adev->primary_output)) {
2781 (out == adev->primary_output)) {
2785 pthread_mutex_unlock(&out->lock);
2800 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2801 parse_compress_metadata(out, parms);
2811 struct stream_out *out = (struct stream_out *)stream;
2824 while (out->supported_channel_masks[i] != 0) {
2826 if (out_channels_name_to_enum_table[j].value == out->supported_channel_masks[i]) {
2850 struct stream_out *out = (struct stream_out *)stream;
2852 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD)
2855 return (out->config.period_count * out->config.period_size * 1000) /
2856 (out->config.rate);
2862 struct stream_out *out = (struct stream_out *)stream;
2863 struct audio_device *adev = out->dev;
2866 if (out->usecase == USECASE_AUDIO_PLAYBACK_MULTI_CH) {
2868 out->muted = (left == 0.0f);
2870 } else if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2921 struct stream_out *out = (struct stream_out *)stream;
2922 struct audio_device *adev = out->dev;
2936 pthread_mutex_lock(&out->lock);
2937 if (out->standby) {
2939 pthread_mutex_unlock(&out->lock);
2942 pthread_mutex_lock(&out->lock);
2943 if (!out->standby) {
2949 ret = start_output_stream(out);
2958 out->standby = false;
2979 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2982 if (out->offload_state == OFFLOAD_STATE_PAUSED_FLUSHED) {
2985 enable_output_path_l(out);
2989 if (out->send_new_metadata) {
2991 compress_set_gapless_metadata(out->compr, &out->gapless_mdata);
2992 out->send_new_metadata = 0;
2995 ret = compress_write(out->compr, buffer, bytes);
2998 send_offload_cmd_l(out, OFFLOAD_CMD_WAIT_FOR_BUFFER);
3000 if (out->offload_state != OFFLOAD_STATE_PLAYING) {
3001 compress_start(out->compr);
3002 out->offload_state = OFFLOAD_STATE_PLAYING;
3004 pthread_mutex_unlock(&out->lock);
3015 != out->echo_reference_generation) {
3017 if (out->echo_reference != NULL) {
3018 ALOGV("%s: release_echo_reference %p", __func__, out->echo_reference);
3019 release_echo_reference(out->echo_reference);
3024 out->echo_reference_generation = adev->echo_reference_generation;
3025 out->echo_reference = adev->echo_reference;
3027 out->echo_reference_generation);
3032 if (out->muted)
3034 list_for_each(node, &out->pcm_dev_list) {
3037 if (bytes * pcm_device->pcm_profile->config.rate / out->sample_rate + frame_size
3040 bytes * pcm_device->pcm_profile->config.rate / out->sample_rate + frame_size;
3056 if (out->echo_reference != NULL && pcm_device->pcm_profile->devices != SND_DEVICE_OUT_SPEAKER) {
3061 get_playback_delay(out, out_frames, &b);
3062 out->echo_reference->write(out->echo_reference, &b);
3066 if (out->devices & AUDIO_DEVICE_OUT_SPEAKER) {
3069 calloc(pcm_frames_to_bytes(pcm_device->pcm, out->config.period_size),
3095 for (i = out->config.period_count; i > 0; i--)
3098 out->config.period_size));
3127 pthread_mutex_unlock(&out->lock);
3146 out->written += bytes / (out->config.channels * sizeof(short));
3150 pthread_mutex_unlock(&out->lock);
3153 list_for_each(node, &out->pcm_dev_list) {
3158 out_standby(&out->stream.common);
3160 out_get_sample_rate(&out->stream.common));
3183 struct stream_out *out = (struct stream_out *)stream;
3185 if ((out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) && (dsp_frames != NULL)) {
3186 pthread_mutex_lock(&out->lock);
3187 if (out->compr != NULL) {
3188 compress_get_tstamp(out->compr, (unsigned long *)dsp_frames,
3189 &out->sample_rate);
3191 __func__, *dsp_frames, out->sample_rate);
3193 pthread_mutex_unlock(&out->lock);
3224 struct stream_out *out = (struct stream_out *)stream;
3228 pthread_mutex_lock(&out->lock);
3230 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
3231 if (out->compr != NULL) {
3232 compress_get_tstamp(out->compr, &dsp_frames,
3233 &out->sample_rate);
3235 __func__, dsp_frames, out->sample_rate);
3243 if (!list_empty(&out->pcm_dev_list)) {
3245 struct pcm_device *pcm_device = node_to_item(list_head(&out->pcm_dev_list),
3249 size_t kernel_buffer_size = out->config.period_size * out->config.period_count;
3250 int64_t signed_frames = out->written - kernel_buffer_size + avail;
3254 (render_latency(out->usecase) * out->sample_rate / 1000000LL);
3265 pthread_mutex_unlock(&out->lock);
3273 struct stream_out *out = (struct stream_out *)stream;
3276 pthread_mutex_lock(&out->lock);
3277 out->offload_callback = callback;
3278 out->offload_cookie = cookie;
3279 pthread_mutex_unlock(&out->lock);
3285 struct stream_out *out = (struct stream_out *)stream;
3288 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
3289 pthread_mutex_lock(&out->lock);
3290 if (out->compr != NULL && out->offload_state == OFFLOAD_STATE_PLAYING) {
3291 status = compress_pause(out->compr);
3292 out->offload_state = OFFLOAD_STATE_PAUSED;
3293 pthread_mutex_lock(&out->dev->lock);
3294 status = disable_output_path_l(out);
3295 pthread_mutex_unlock(&out->dev->lock);
3297 pthread_mutex_unlock(&out->lock);
3304 struct stream_out *out = (struct stream_out *)stream;
3307 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
3309 pthread_mutex_lock(&out->lock);
3310 if (out->compr != NULL && out->offload_state == OFFLOAD_STATE_PAUSED) {
3311 pthread_mutex_lock(&out->dev->lock);
3312 enable_output_path_l(out);
3313 pthread_mutex_unlock(&out->dev->lock);
3314 status = compress_resume(out->compr);
3315 out->offload_state = OFFLOAD_STATE_PLAYING;
3317 pthread_mutex_unlock(&out->lock);
3324 struct stream_out *out = (struct stream_out *)stream;
3327 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
3328 pthread_mutex_lock(&out->lock);
3330 status = send_offload_cmd_l(out, OFFLOAD_CMD_PARTIAL_DRAIN);
3332 status = send_offload_cmd_l(out, OFFLOAD_CMD_DRAIN);
3333 pthread_mutex_unlock(&out->lock);
3340 struct stream_out *out = (struct stream_out *)stream;
3342 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
3343 pthread_mutex_lock(&out->lock);
3344 if (out->offload_state == OFFLOAD_STATE_PLAYING) {
3345 ALOGE("out_flush() called in wrong state %d", out->offload_state);
3346 pthread_mutex_unlock(&out->lock);
3349 if (out->offload_state == OFFLOAD_STATE_PAUSED) {
3350 stop_compressed_output_l(out);
3351 out->offload_state = OFFLOAD_STATE_PAUSED_FLUSHED;
3353 pthread_mutex_unlock(&out->lock);
3797 struct stream_out *out;
3804 out = (struct stream_out *)calloc(1, sizeof(struct stream_out));
3809 out->flags = flags;
3810 out->devices = devices;
3811 out->dev = adev;
3812 out->format = config->format;
3813 out->sample_rate = config->sample_rate;
3814 out->channel_mask = AUDIO_CHANNEL_OUT_STEREO;
3815 out->supported_channel_masks[0] = AUDIO_CHANNEL_OUT_STEREO;
3816 out->handle = handle;
3823 out->config = pcm_profile->config;
3826 if (out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) {
3839 out->compr_config.codec = (struct snd_codec *)
3842 out->usecase = USECASE_AUDIO_PLAYBACK_OFFLOAD;
3844 out->channel_mask = config->offload_info.channel_mask;
3846 out->channel_mask = config->channel_mask;
3847 out->format = config->offload_info.format;
3848 out->sample_rate = config->offload_info.sample_rate;
3850 out->stream.set_callback = out_set_callback;
3851 out->stream.pause = out_pause;
3852 out->stream.resume = out_resume;
3853 out->stream.drain = out_drain;
3854 out->stream.flush = out_flush;
3856 out->compr_config.codec->id =
3858 out->compr_config.fragment_size = COMPRESS_OFFLOAD_FRAGMENT_SIZE;
3859 out->compr_config.fragments = COMPRESS_OFFLOAD_NUM_FRAGMENTS;
3860 out->compr_config.codec->sample_rate = config->offload_info.sample_rate;
3861 out->compr_config.codec->bit_rate =
3863 out->compr_config.codec->ch_in =
3865 out->compr_config.codec->ch_out = out->compr_config.codec->ch_in;
3868 out->non_blocking = 1;
3870 out->send_new_metadata = 1;
3871 create_offload_callback_thread(out);
3872 out->offload_state = OFFLOAD_STATE_IDLE;
3877 } else if (out->flags & (AUDIO_OUTPUT_FLAG_DEEP_BUFFER)) {
3878 out->usecase = USECASE_AUDIO_PLAYBACK_DEEP_BUFFER;
3879 out->config = pcm_config_deep_buffer;
3880 out->sample_rate = out->config.rate;
3883 out->usecase = USECASE_AUDIO_PLAYBACK;
3884 out->sample_rate = out->config.rate;
3889 adev->primary_output = out;
3899 if (get_usecase_from_id(adev, out->usecase) != NULL) {
3900 ALOGE("%s: Usecase (%d) is already present", __func__, out->usecase);
3907 out->stream.common.get_sample_rate = out_get_sample_rate;
3908 out->stream.common.set_sample_rate = out_set_sample_rate;
3909 out->stream.common.get_buffer_size = out_get_buffer_size;
3910 out->stream.common.get_channels = out_get_channels;
3911 out->stream.common.get_format = out_get_format;
3912 out->stream.common.set_format = out_set_format;
3913 out->stream.common.standby = out_standby;
3914 out->stream.common.dump = out_dump;
3915 out->stream.common.set_parameters = out_set_parameters;
3916 out->stream.common.get_parameters = out_get_parameters;
3917 out->stream.common.add_audio_effect = out_add_audio_effect;
3918 out->stream.common.remove_audio_effect = out_remove_audio_effect;
3919 out->stream.get_latency = out_get_latency;
3920 out->stream.set_volume = out_set_volume;
3921 out->stream.write = out_write;
3922 out->stream.get_render_position = out_get_render_position;
3923 out->stream.get_next_write_timestamp = out_get_next_write_timestamp;
3924 out->stream.get_presentation_position = out_get_presentation_position;
3926 out->standby = 1;
3927 /* out->muted = false; by calloc() */
3928 /* out->written = 0; by calloc() */
3930 pthread_mutex_init(&out->lock, (const pthread_mutexattr_t *) NULL);
3931 pthread_cond_init(&out->cond, (const pthread_condattr_t *) NULL);
3933 config->format = out->stream.common.get_format(&out->stream.common);
3934 config->channel_mask = out->stream.common.get_channels(&out->stream.common);
3935 config->sample_rate = out->stream.common.get_sample_rate(&out->stream.common);
3937 *stream_out = &out->stream;
3942 free(out);
3951 struct stream_out *out = (struct stream_out *)stream;
3952 struct audio_device *adev = out->dev;
3957 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
3958 destroy_offload_callback_thread(out);
3960 if (out->compr_config.codec != NULL)
3961 free(out->compr_config.codec);
3963 pthread_cond_destroy(&out->cond);
3964 pthread_mutex_destroy(&out->lock);
