Lines Matching defs:out
331 static int check_a2dp_restore_l(struct audio_device *adev, struct stream_out *out, bool restore);
355 static void register_out_stream(struct stream_out *out)
357 struct audio_device *adev = out->dev;
358 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD)
365 out->handle,
366 out->flags);
371 if (out->realtime) {
373 out->handle,
374 out->pcm, &out->config);
399 static void request_out_focus(struct stream_out *out, long ns)
401 struct audio_device *adev = out->dev;
404 adev->adm_request_focus_v2(adev->adm_data, out->handle, ns);
406 adev->adm_request_focus(adev->adm_data, out->handle);
421 static void release_out_focus(struct stream_out *out, long ns __unused)
423 struct audio_device *adev = out->dev;
426 adev->adm_abandon_focus(adev->adm_data, out->handle);
850 audio_devices_t a1 = uc->stream.out->devices;
851 audio_devices_t a2 = new_uc->stream.out->devices;
1050 static int read_hdmi_channel_masks(struct stream_out *out)
1053 int channels = platform_edid_get_max_channels(out->dev->platform);
1062 out->supported_channel_masks[0] = AUDIO_CHANNEL_OUT_5POINT1;
1066 out->supported_channel_masks[0] = AUDIO_CHANNEL_OUT_5POINT1;
1067 out->supported_channel_masks[1] = AUDIO_CHANNEL_OUT_7POINT1;
1242 if (usecase->stream.out == NULL) {
1243 ALOGE("%s: stream.out is NULL", __func__);
1250 if ((usecase->stream.out->devices & AUDIO_DEVICE_OUT_ALL_A2DP) &&
1282 usecase->stream.out->devices);
1283 in_snd_device = platform_get_input_snd_device(adev->platform, usecase->stream.out->devices);
1284 usecase->devices = usecase->stream.out->devices;
1311 usecase->devices = usecase->stream.out->devices;
1317 usecase->stream.out->devices);
1320 voip_out = voip_usecase->stream.out;
1322 if (usecase->stream.out == voip_out &&
1345 out_device = voip_usecase->stream.out->devices;
1486 struct stream_out *voip_out = voip_usecase->stream.out;
1673 void lock_output_stream(struct stream_out *out)
1675 pthread_mutex_lock(&out->pre_lock);
1676 pthread_mutex_lock(&out->lock);
1677 pthread_mutex_unlock(&out->pre_lock);
1680 /* must be called with out->lock locked */
1681 static int send_offload_cmd_l(struct stream_out* out, int command)
1688 list_add_tail(&out->offload_cmd_list, &cmd->node);
1689 pthread_cond_signal(&out->offload_cond);
1693 /* must be called iwth out->lock locked */
1694 static void stop_compressed_output_l(struct stream_out *out)
1696 out->offload_state = OFFLOAD_STATE_IDLE;
1697 out->playback_started = 0;
1698 out->send_new_metadata = 1;
1699 if (out->compr != NULL) {
1700 compress_stop(out->compr);
1701 while (out->offload_thread_blocked) {
1702 pthread_cond_wait(&out->cond, &out->lock);
1709 struct stream_out *out = (struct stream_out *) context;
1712 out->offload_state = OFFLOAD_STATE_IDLE;
1713 out->playback_started = 0;
1720 lock_output_stream(out);
1726 ALOGVV("%s offload_cmd_list %d out->offload_state %d",
1727 __func__, list_empty(&out->offload_cmd_list),
1728 out->offload_state);
1729 if (list_empty(&out->offload_cmd_list)) {
1731 pthread_cond_wait(&out->offload_cond, &out->lock);
1736 item = list_head(&out->offload_cmd_list);
1740 ALOGVV("%s STATE %d CMD %d out->compr %p",
1741 __func__, out->offload_state, cmd->cmd, out->compr);
1748 if (out->compr == NULL) {
1751 pthread_cond_signal(&out->cond);
1754 out->offload_thread_blocked = true;
1755 pthread_mutex_unlock(&out->lock);
1759 compress_wait(out->compr, -1);
1764 compress_next_track(out->compr);
1765 compress_partial_drain(out->compr);
1769 out->send_new_metadata = 1;
1772 compress_drain(out->compr);
1784 lock_output_stream(out);
1785 out->offload_thread_blocked = false;
1786 pthread_cond_signal(&out->cond);
1789 out->offload_callback(event, NULL, out->offload_cookie);
1794 pthread_cond_signal(&out->cond);
1795 while (!list_empty(&out->offload_cmd_list)) {
1796 item = list_head(&out->offload_cmd_list);
1800 pthread_mutex_unlock(&out->lock);
1805 static int create_offload_callback_thread(struct stream_out *out)
1807 pthread_cond_init(&out->offload_cond, (const pthread_condattr_t *) NULL);
1808 list_init(&out->offload_cmd_list);
1809 pthread_create(&out->offload_thread, (const pthread_attr_t *) NULL,
1810 offload_thread_loop, out);
1814 static int destroy_offload_callback_thread(struct stream_out *out)
1816 lock_output_stream(out);
1817 stop_compressed_output_l(out);
1818 send_offload_cmd_l(out, OFFLOAD_CMD_EXIT);
1820 pthread_mutex_unlock(&out->lock);
1821 pthread_join(out->offload_thread, (void **) NULL);
1822 pthread_cond_destroy(&out->offload_cond);
1952 static int stop_output_stream(struct stream_out *out)
1956 struct audio_device *adev = out->dev;
1959 out->usecase, use_case_table[out->usecase]);
1960 uc_info = get_usecase_from_list(adev, out->usecase);
1963 __func__, out->usecase);
1967 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1969 adev->visualizer_stop_output(out->handle, out->pcm_device_id);
1971 adev->offload_effects_stop_output(out->handle, out->pcm_device_id);
1972 } else if (out->usecase == USECASE_AUDIO_PLAYBACK_ULL ||
1973 out->usecase == USECASE_AUDIO_PLAYBACK_MMAP) {
1988 if (out->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL)
1990 else if (out->devices & AUDIO_DEVICE_OUT_SPEAKER_SAFE) {
1998 } else if (audio_is_usb_out_device(out->devices & AUDIO_DEVICE_OUT_ALL_USB)) {
2013 int start_output_stream(struct stream_out *out)
2017 struct audio_device *adev = out->dev;
2021 __func__, out->usecase, use_case_table[out->usecase], out->devices);
2023 if (out->card_status == CARD_STATUS_OFFLINE ||
2025 ALOGW("out->card_status or adev->card_status offline, try again");
2030 if (out->devices & AUDIO_DEVICE_OUT_ALL_A2DP) {
2032 if (out->devices & (AUDIO_DEVICE_OUT_SPEAKER | AUDIO_DEVICE_OUT_SPEAKER_SAFE)) {
2035 if (!(out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD)) {
2043 out->pcm_device_id = platform_get_pcm_device_id(out->usecase, PCM_PLAYBACK);
2044 if (out->pcm_device_id < 0) {
2046 __func__, out->pcm_device_id, out->usecase);
2052 uc_info->id = out->usecase;
2054 uc_info->stream.out = out;
2055 uc_info->devices = out->devices;
2060 if (out->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL)
2061 check_and_set_hdmi_channels(adev, out->config.channels);
2062 else if (audio_is_usb_out_device(out->devices & AUDIO_DEVICE_OUT_ALL_USB)) {
2073 if ((out->devices & AUDIO_DEVICE_OUT_ALL_A2DP) &&
2076 check_a2dp_restore_l(adev, out, false);
2078 audio_devices_t dev = out->devices;
2080 out->devices = AUDIO_DEVICE_OUT_SPEAKER_SAFE;
2082 out->devices = AUDIO_DEVICE_OUT_SPEAKER;
2083 select_devices(adev, out->usecase);
2084 out->devices = dev;
2087 select_devices(adev, out->usecase);
2093 __func__, adev->snd_card, out->pcm_device_id, out->config.format);
2094 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2095 out->pcm = NULL;
2096 out->compr = compress_open(adev->snd_card, out->pcm_device_id,
2097 COMPRESS_IN, &out->compr_config);
2098 if (out->compr && !is_compress_ready(out->compr)) {
2099 ALOGE("%s: %s", __func__, compress_get_error(out->compr));
2100 compress_close(out->compr);
2101 out->compr = NULL;
2105 if (out->offload_callback)
2106 compress_nonblock(out->compr, out->non_blocking);
2109 adev->visualizer_start_output(out->handle, out->pcm_device_id);
2111 adev->offload_effects_start_output(out->handle, out->pcm_device_id);
2112 } else if (out->usecase == USECASE_AUDIO_PLAYBACK_MMAP) {
2113 if (out->pcm == NULL || !pcm_is_ready(out->pcm)) {
2117 ret = pcm_start(out->pcm);
2126 if (out->usecase == USECASE_AUDIO_PLAYBACK_AFE_PROXY) {
2129 } else if (out->realtime) {
2134 out->pcm = pcm_open(adev->snd_card, out->pcm_device_id,
2135 flags, &out->config);
2136 if (out->pcm == NULL || !pcm_is_ready(out->pcm)) {
2137 ALOGE("%s: %s", __func__, pcm_get_error(out->pcm));
2138 if (out->pcm != NULL) {
2139 pcm_close(out->pcm);
2140 out->pcm = NULL;
2152 if (pcm_is_ready(out->pcm)) {
2153 ret = pcm_prepare(out->pcm);
2156 pcm_close(out->pcm);
2157 out->pcm = NULL;
2161 if (out->realtime) {
2162 ret = pcm_start(out->pcm);
2165 pcm_close(out->pcm);
2166 out->pcm = NULL;
2171 register_out_stream(out);
2176 if (out->usecase == USECASE_AUDIO_PLAYBACK_ULL ||
2177 out->usecase == USECASE_AUDIO_PLAYBACK_MMAP) {
2193 stop_output_stream(out);
2308 struct stream_out *out = (struct stream_out *)stream;
2310 return out->sample_rate;
2320 struct stream_out *out = (struct stream_out *)stream;
2322 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2323 return out->compr_config.fragment_size;
2325 return out->config.period_size * out->af_period_multiplier *
2331 struct stream_out *out = (struct stream_out *)stream;
2333 return out->channel_mask;
2338 struct stream_out *out = (struct stream_out *)stream;
2340 return out->format;
2348 /* must be called with out->lock locked */
2351 struct stream_out *out = (struct stream_out *)stream;
2352 struct audio_device *adev = out->dev;
2355 if (!out->standby) {
2357 adev->adm_deregister_stream(adev->adm_data, out->handle);
2359 out->standby = true;
2360 if (out->usecase != USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2361 if (out->pcm) {
2362 pcm_close(out->pcm);
2363 out->pcm = NULL;
2365 if (out->usecase == USECASE_AUDIO_PLAYBACK_MMAP) {
2366 do_stop = out->playback_started;
2367 out->playback_started = false;
2370 stop_compressed_output_l(out);
2371 out->gapless_mdata.encoder_delay = 0;
2372 out->gapless_mdata.encoder_padding = 0;
2373 if (out->compr != NULL) {
2374 compress_close(out->compr);
2375 out->compr = NULL;
2379 stop_output_stream(out);
2388 struct stream_out *out = (struct stream_out *)stream;
2391 out->usecase, use_case_table[out->usecase]);
2393 lock_output_stream(out);
2395 pthread_mutex_unlock(&out->lock);
2402 struct stream_out *out = (struct stream_out *)stream;
2403 struct audio_device *adev = out->dev;
2406 lock_output_stream(out);
2407 if (!out->standby) {
2408 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2409 stop_compressed_output_l(out);
2410 send_offload_cmd_l(out, OFFLOAD_CMD_ERROR);
2414 pthread_mutex_unlock(&out->lock);
2417 return out_standby(&out->stream.common);
2424 struct stream_out *out = (struct stream_out *)stream;
2429 const bool locked = (pthread_mutex_trylock(&out->lock) == 0);
2430 dprintf(fd, " Standby: %s\n", out->standby ? "yes" : "no");
2431 dprintf(fd, " Frames written: %lld\n", (long long)out->written);
2434 pthread_mutex_unlock(&out->lock);
2439 out->error_log, fd, " " /* prefix */, 0 /* lines */, 0 /* limit_ns */);
2444 static int parse_compress_metadata(struct stream_out *out, struct str_parms *parms)
2450 if (!out || !parms) {
2468 out->gapless_mdata = tmp_mdata;
2469 out->send_new_metadata = 1;
2471 out->gapless_mdata.encoder_delay, out->gapless_mdata.encoder_padding);
2476 static bool output_drives_call(struct audio_device *adev, struct stream_out *out)
2478 return out == adev->primary_output || out == adev->voice_tx_output;
2492 struct stream_out *out = (struct stream_out *)stream;
2493 struct audio_device *adev = out->dev;
2504 __func__, out->usecase, use_case_table[out->usecase], kvpairs);
2510 lock_output_stream(out);
2516 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD && val == AUDIO_DEVICE_NONE &&
2517 audio_is_usb_out_device(out->devices)) {
2519 out_standby_l(&out->stream.common);
2531 if (out->devices == AUDIO_DEVICE_OUT_AUX_DIGITAL &&
2543 if ((out->devices & AUDIO_DEVICE_OUT_BLUETOOTH_A2DP) &&
2564 out->devices = val;
2565 pthread_mutex_unlock(&out->lock);
2583 pthread_mutex_unlock(&out->lock);
2607 bool same_dev = out->devices == new_dev;
2608 out->devices = new_dev;
2610 if (output_drives_call(adev, out)) {
2613 adev->current_call_output = out;
2617 adev->current_call_output = out;
2622 if (!out->standby) {
2628 out->handle);
2632 select_devices(adev, out->usecase);
2635 out->devices = AUDIO_DEVICE_OUT_SPEAKER_SAFE;
2637 out->devices = AUDIO_DEVICE_OUT_SPEAKER;
2638 select_devices(adev, out->usecase);
2639 out->devices = new_dev;
2649 if ((out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) &&
2650 out->a2dp_compress_mute &&
2651 (!(out->devices & AUDIO_DEVICE_OUT_ALL_A2DP) || audio_extn_a2dp_is_ready())) {
2652 pthread_mutex_lock(&out->compr_mute_lock);
2653 out->a2dp_compress_mute = false;
2654 set_compr_volume(&out->stream, out->volume_l, out->volume_r);
2655 pthread_mutex_unlock(&out->compr_mute_lock);
2662 pthread_mutex_unlock(&out->lock);
2669 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2670 parse_compress_metadata(out, parms);
2777 struct stream_out *out = (struct stream_out *)stream;
2785 &out->supported_channel_masks[0]);
2787 &out->supported_formats[0]);
2789 &out->supported_sample_rates[0]);
2804 struct stream_out *out = (struct stream_out *)stream;
2807 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD)
2809 else if ((out->realtime) ||
2810 (out->usecase == USECASE_AUDIO_PLAYBACK_MMAP)) {
2813 period_ms = (out->af_period_multiplier * out->config.period_size *
2814 1000) / (out->config.rate);
2815 hw_delay = platform_render_latency(out->usecase)/1000;
2819 latency = (out->config.period_count * out->config.period_size * 1000) /
2820 (out->config.rate);
2822 if (AUDIO_DEVICE_OUT_ALL_A2DP & out->devices)
2831 struct stream_out *out = (struct stream_out *)stream;
2834 struct audio_device *adev = out->dev;
2836 int pcm_device_id = platform_get_pcm_device_id(out->usecase,
2859 struct stream_out *out = (struct stream_out *)stream;
2862 if (out->usecase == USECASE_AUDIO_PLAYBACK_HIFI) {
2864 out->muted = (left == 0.0f);
2866 } else if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2867 pthread_mutex_lock(&out->compr_mute_lock);
2868 ALOGV("%s: compress mute %d", __func__, out->a2dp_compress_mute);
2869 if (!out->a2dp_compress_mute)
2871 out->volume_l = left;
2872 out->volume_r = right;
2873 pthread_mutex_unlock(&out->compr_mute_lock);
2875 } else if (out->usecase == USECASE_AUDIO_PLAYBACK_VOIP) {
2876 out->app_type_cfg.gain[0] = (int)(left * VOIP_PLAYBACK_VOLUME_MAX);
2877 out->app_type_cfg.gain[1] = (int)(right * VOIP_PLAYBACK_VOLUME_MAX);
2878 if (!out->standby) {
2880 audio_extn_utils_send_app_type_gain(out->dev,
2881 out->app_type_cfg.app_type,
2882 &out->app_type_cfg.gain[0]);
2897 struct stream_out *out = (struct stream_out *)stream;
2898 struct audio_device *adev = out->dev;
2912 lock_output_stream(out);
2913 if (out->card_status != status)
2914 out->card_status = status;
2915 pthread_mutex_unlock(&out->lock);
2918 use_case_table[out->usecase],
2931 struct stream_out *out = (struct stream_out *)stream;
2936 lock_output_stream(out);
2938 (const struct audio_stream_out *)&out->stream) /
2939 out_get_sample_rate(&out->stream.common));
2940 pthread_mutex_unlock(&out->lock);
2948 struct stream_out *out = (struct stream_out *)stream;
2949 struct audio_device *adev = out->dev;
2953 lock_output_stream(out);
2958 if (out->usecase == USECASE_AUDIO_PLAYBACK_MMAP) {
2963 if ((out->devices & AUDIO_DEVICE_OUT_ALL_A2DP) &&
2965 if (!(out->devices & (AUDIO_DEVICE_OUT_SPEAKER | AUDIO_DEVICE_OUT_SPEAKER_SAFE))) {
2966 if (!(out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD)) {
2973 if (out->standby) {
2974 out->standby = false;
2976 ret = start_output_stream(out);
2980 out->standby = true;
2992 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2994 if (out->send_new_metadata) {
2996 compress_set_gapless_metadata(out->compr, &out->gapless_mdata);
2997 out->send_new_metadata = 0;
3001 ret = compress_get_hpointer(out->compr, &avail, &tstamp);
3012 ret = compress_write(out->compr, buffer, avail);
3018 send_offload_cmd_l(out, OFFLOAD_CMD_WAIT_FOR_BUFFER);
3020 if (ret > 0 && !out->playback_started) {
3021 compress_start(out->compr);
3022 out->playback_started = 1;
3023 out->offload_state = OFFLOAD_STATE_PLAYING;
3026 error_log_log(out->error_log, ERROR_CODE_WRITE, audio_utils_get_real_time_ns());
3028 out->written += ret; // accumulate bytes written for offload.
3030 pthread_mutex_unlock(&out->lock);
3035 if (out->pcm) {
3038 if (out->muted)
3041 if (out->usecase == USECASE_AUDIO_PLAYBACK_VOIP || out->usecase == USECASE_INCALL_MUSIC_UPLINK) {
3042 size_t channel_count = audio_channel_count_from_out_mask(out->channel_mask);
3046 LOG_ALWAYS_FATAL_IF(out->config.channels != 1 || channel_count != 2 ||
3047 out->format != AUDIO_FORMAT_PCM_16_BIT,
3057 long ns = (frames * (int64_t) NANOS_PER_SECOND) / out->config.rate;
3058 request_out_focus(out, ns);
3060 bool use_mmap = is_mmap_usecase(out->usecase) || out->realtime;
3062 ret = pcm_mmap_write(out->pcm, (void *)buffer, bytes_to_write);
3064 ret = pcm_write(out->pcm, (void *)buffer, bytes_to_write);
3066 release_out_focus(out, ns);
3068 LOG_ALWAYS_FATAL("out->pcm is NULL after starting output stream");
3074 if (out->usecase != USECASE_AUDIO_PLAYBACK_OFFLOAD) {
3075 out->written += frames;
3080 error_log_log(out->error_log, error_code, audio_utils_get_real_time_ns());
3081 if (out->usecase != USECASE_AUDIO_PLAYBACK_OFFLOAD) {
3082 ALOGE_IF(out->pcm != NULL,
3083 "%s: error %zd - %s", __func__, ret, pcm_get_error(out->pcm));
3084 sleeptime_us = frames * 1000000LL / out_get_sample_rate(&out->stream.common);
3089 pthread_mutex_unlock(&out->lock);
3092 out_on_error(&out->stream.common);
3102 struct stream_out *out = (struct stream_out *)stream;
3104 if ((out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) && (dsp_frames != NULL)) {
3105 lock_output_stream(out);
3106 if (out->compr != NULL) {
3109 compress_get_tstamp(out->compr, &frames, &out->sample_rate);
3112 __func__, *dsp_frames, out->sample_rate);
3114 pthread_mutex_unlock(&out->lock);
3141 struct stream_out *out = (struct stream_out *)stream;
3145 lock_output_stream(out);
3147 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
3148 if (out->compr != NULL) {
3150 compress_get_tstamp(out->compr, &dsp_frames,
3151 &out->sample_rate);
3154 if (AUDIO_DEVICE_OUT_ALL_A2DP & out->devices) {
3156 (audio_extn_a2dp_get_encoder_latency() * out->sample_rate / 1000);
3160 __func__, dsp_frames, out->sample_rate);
3167 if (out->pcm) {
3169 if (pcm_get_htimestamp(out->pcm, &avail, timestamp) == 0) {
3170 size_t kernel_buffer_size = out->config.period_size * out->config.period_count;
3171 int64_t signed_frames = out->written - kernel_buffer_size + avail;
3175 (platform_render_latency(out->usecase) * out->sample_rate / 1000000LL);
3179 if (AUDIO_DEVICE_OUT_ALL_A2DP & out->devices) {
3181 (audio_extn_a2dp_get_encoder_latency() * out->sample_rate / 1000);
3193 pthread_mutex_unlock(&out->lock);
3201 struct stream_out *out = (struct stream_out *)stream;
3204 lock_output_stream(out);
3205 out->offload_callback = callback;
3206 out->offload_cookie = cookie;
3207 pthread_mutex_unlock(&out->lock);
3213 struct stream_out *out = (struct stream_out *)stream;
3216 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
3217 lock_output_stream(out);
3218 if (out->compr != NULL && out->offload_state == OFFLOAD_STATE_PLAYING) {
3219 status = compress_pause(out->compr);
3220 out->offload_state = OFFLOAD_STATE_PAUSED;
3222 pthread_mutex_unlock(&out->lock);
3229 struct stream_out *out = (struct stream_out *)stream;
3232 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
3234 lock_output_stream(out);
3235 if (out->compr != NULL && out->offload_state == OFFLOAD_STATE_PAUSED) {
3236 status = compress_resume(out->compr);
3237 out->offload_state = OFFLOAD_STATE_PLAYING;
3239 pthread_mutex_unlock(&out->lock);
3246 struct stream_out *out = (struct stream_out *)stream;
3249 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
3250 lock_output_stream(out);
3252 status = send_offload_cmd_l(out, OFFLOAD_CMD_PARTIAL_DRAIN);
3254 status = send_offload_cmd_l(out, OFFLOAD_CMD_DRAIN);
3255 pthread_mutex_unlock(&out->lock);
3262 struct stream_out *out = (struct stream_out *)stream;
3264 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
3265 lock_output_stream(out);
3266 stop_compressed_output_l(out);
3267 pthread_mutex_unlock(&out->lock);
3275 struct stream_out *out = (struct stream_out *)stream;
3276 struct audio_device *adev = out->dev;
3281 if (out->usecase == USECASE_AUDIO_PLAYBACK_MMAP && !out->standby &&
3282 out->playback_started && out->pcm != NULL) {
3283 pcm_stop(out->pcm);
3284 ret = stop_output_stream(out);
3285 out->playback_started = false;
3293 struct stream_out *out = (struct stream_out *)stream;
3294 struct audio_device *adev = out->dev;
3299 if (out->usecase == USECASE_AUDIO_PLAYBACK_MMAP && !out->standby &&
3300 !out->playback_started && out->pcm != NULL) {
3301 ret = start_output_stream(out);
3303 out->playback_started = true;
3334 struct stream_out *out = (struct stream_out *)stream;
3335 struct audio_device *adev = out->dev;
3344 lock_output_stream(out);
3352 if (out->usecase != USECASE_AUDIO_PLAYBACK_MMAP || !out->standby) {
3353 ALOGE("%s: usecase = %d, standby = %d", __func__, out->usecase, out->standby);
3357 out->pcm_device_id = platform_get_pcm_device_id(out->usecase, PCM_PLAYBACK);
3358 if (out->pcm_device_id < 0) {
3360 __func__, out->pcm_device_id, out->usecase);
3365 adjust_mmap_period_count(&out->config, min_size_frames);
3368 __func__, adev->snd_card, out->pcm_device_id, out->config.channels);
3369 out->pcm = pcm_open(adev->snd_card, out->pcm_device_id,
3370 (PCM_OUT | PCM_MMAP | PCM_NOIRQ | PCM_MONOTONIC), &out->config);
3371 if (out->pcm == NULL || !pcm_is_ready(out->pcm)) {
3376 ret = pcm_mmap_begin(out->pcm, &info->shared_memory_address, &offset1, &frames1);
3381 info->buffer_size_frames = pcm_get_buffer_size(out->pcm);
3382 buffer_size = pcm_frames_to_bytes(out->pcm, info->buffer_size_frames);
3383 info->burst_size_frames = out->config.period_size;
3385 out->pcm_device_id, 0 /*playback*/,
3390 info->shared_memory_fd = pcm_get_poll_fd(out->pcm);
3401 ret = pcm_mmap_commit(out->pcm, 0, MMAP_PERIOD_SIZE);
3407 out->standby = false;
3415 if (out->pcm == NULL) {
3418 ALOGE("%s: %s %s", __func__, step, pcm_get_error(out->pcm));
3419 pcm_close(out->pcm);
3420 out->pcm = NULL;
3424 pthread_mutex_unlock(&out->lock);
3432 struct stream_out *out = (struct stream_out *)stream;
3437 lock_output_stream(out);
3438 if (out->usecase != USECASE_AUDIO_PLAYBACK_MMAP ||
3439 out->pcm == NULL) {
3445 ret = pcm_mmap_get_hw_ptr(out->pcm, (unsigned int *)&position->position_frames, &ts);
3447 ALOGE("%s: %s", __func__, pcm_get_error(out->pcm));
3452 pthread_mutex_unlock(&out->lock);
3731 int error_code = ERROR_CODE_STANDBY; // initial errors are considered coming out of standby.
4132 struct stream_out *out;
4145 out = (struct stream_out *)calloc(1, sizeof(struct stream_out));
4147 pthread_mutex_init(&out->compr_mute_lock, (const pthread_mutexattr_t *) NULL);
4152 out->flags = flags;
4153 out->devices = devices;
4154 out->dev = adev;
4155 out->handle = handle;
4156 out->a2dp_compress_mute = false;
4169 ret = read_hdmi_channel_masks(out);
4179 &out->supported_formats[0],
4182 &out->supported_channel_masks[0],
4185 &out->supported_sample_rates[0],
4203 out->sample_rate = config->sample_rate;
4204 out->channel_mask = config->channel_mask;
4205 out->format = config->format;
4207 out->usecase = USECASE_AUDIO_PLAYBACK_HIFI;
4208 out->config = pcm_config_hdmi_multi;
4210 out->usecase = USECASE_AUDIO_PLAYBACK_MMAP;
4211 out->config = pcm_config_mmap_playback;
4212 out->stream.start = out_start;
4213 out->stream.stop = out_stop;
4214 out->stream.create_mmap_buffer = out_create_mmap_buffer;
4215 out->stream.get_mmap_position = out_get_mmap_position;
4217 out->usecase = USECASE_AUDIO_PLAYBACK_HIFI;
4218 out->config = pcm_config_hifi;
4221 out->config.rate = out->sample_rate;
4222 out->config.channels = audio_channel_count_from_out_mask(out->channel_mask);
4224 out->config.period_size = HDMI_MULTI_PERIOD_BYTES / (out->config.channels *
4225 audio_bytes_per_sample(out->format));
4227 out->config.format = pcm_format_from_audio_format(out->format);
4251 out->sample_rate = config->offload_info.sample_rate;
4253 out->channel_mask = config->offload_info.channel_mask;
4255 out->channel_mask = config->channel_mask;
4257 out->channel_mask = AUDIO_CHANNEL_OUT_STEREO;
4259 out->format = config->offload_info.format;
4261 out->compr_config.codec = (struct snd_codec *)
4264 out->usecase = USECASE_AUDIO_PLAYBACK_OFFLOAD;
4266 out->stream.set_callback = out_set_callback;
4267 out->stream.pause = out_pause;
4268 out->stream.resume = out_resume;
4269 out->stream.drain = out_drain;
4270 out->stream.flush = out_flush;
4272 out->compr_config.codec->id =
4274 out->compr_config.fragment_size = COMPRESS_OFFLOAD_FRAGMENT_SIZE;
4275 out->compr_config.fragments = COMPRESS_OFFLOAD_NUM_FRAGMENTS;
4276 out->compr_config.codec->sample_rate = out->sample_rate;
4277 out->compr_config.codec->bit_rate =
4279 out->compr_config.codec->ch_in =
4280 audio_channel_count_from_out_mask(out->channel_mask);
4281 out->compr_config.codec->ch_out = out->compr_config.codec->ch_in;
4284 out->non_blocking = 1;
4286 out->send_new_metadata = 1;
4287 create_offload_callback_thread(out);
4291 } else if (out->flags & AUDIO_OUTPUT_FLAG_INCALL_MUSIC) {
4294 out->sample_rate = DEFAULT_OUTPUT_SAMPLING_RATE;
4299 out->sample_rate = config->sample_rate;
4312 out->channel_mask = AUDIO_CHANNEL_OUT_STEREO;
4324 out->format = AUDIO_FORMAT_PCM_16_BIT;
4334 voice_extn_check_and_set_incall_music_usecase(adev, out);
4335 } else if (out->devices == AUDIO_DEVICE_OUT_TELEPHONY_TX) {
4338 out->sample_rate = AFE_PROXY_SAMPLING_RATE;
4343 out->sample_rate = config->sample_rate;
4355 out->channel_mask = AUDIO_CHANNEL_OUT_STEREO;
4358 out->channel_mask = config->channel_mask;
4369 out->format = AUDIO_FORMAT_PCM_16_BIT;
4372 out->format = config->format;
4384 out->usecase = USECASE_AUDIO_PLAYBACK_AFE_PROXY;
4385 out->config = pcm_config_afe_proxy_playback;
4386 out->config.rate = out->sample_rate;
4387 out->config.channels =
4388 audio_channel_count_from_out_mask(out->channel_mask);
4389 out->config.format = pcm_format_from_audio_format(out->format);
4390 adev->voice_tx_output = out;
4394 out->sample_rate = DEFAULT_OUTPUT_SAMPLING_RATE;
4400 out->sample_rate = config->sample_rate;
4412 out->channel_mask = AUDIO_CHANNEL_OUT_STEREO;
4415 out->channel_mask = config->channel_mask;
4426 out->format = AUDIO_FORMAT_PCM_16_BIT;
4429 out->format = config->format;
4442 out->usecase = USECASE_AUDIO_PLAYBACK_VOIP;
4443 out->config = pcm_config_voip;
4444 out->config.rate = out->sample_rate;
4445 out->config.format = pcm_format_from_audio_format(out->format);
4447 out->sample_rate,
4448 out->format,
4449 out->config.channels,
4451 frame_size = audio_bytes_per_sample(out->format) * out->config.channels;
4452 out->config.period_size = buffer_size / frame_size;
4453 out->config.period_count = VOIP_PLAYBACK_PERIOD_COUNT;
4454 out->af_period_multiplier = 1;
4457 out->usecase = USECASE_AUDIO_PLAYBACK_DEEP_BUFFER;
4458 out->config = pcm_config_deep_buffer;
4460 out->usecase = USECASE_AUDIO_PLAYBACK_TTS;
4461 out->config = pcm_config_deep_buffer;
4463 out->usecase = USECASE_AUDIO_PLAYBACK_ULL;
4464 out->realtime = may_use_noirq_mode(adev, USECASE_AUDIO_PLAYBACK_ULL, out->flags);
4465 out->config = out->realtime ? pcm_config_rt : pcm_config_low_latency;
4467 out->usecase = USECASE_AUDIO_PLAYBACK_MMAP;
4468 out->config = pcm_config_mmap_playback;
4469 out->stream.start = out_start;
4470 out->stream.stop = out_stop;
4471 out->stream.create_mmap_buffer = out_create_mmap_buffer;
4472 out->stream.get_mmap_position = out_get_mmap_position;
4474 out->usecase = USECASE_AUDIO_PLAYBACK_LOW_LATENCY;
4475 out->config = pcm_config_low_latency;
4479 out->sample_rate = out->config.rate;
4481 out->sample_rate = config->sample_rate;
4484 out->channel_mask = audio_channel_out_mask_from_count(out->config.channels);
4486 out->channel_mask = config->channel_mask;
4489 out->format = audio_format_from_pcm_format(out->config.format);
4495 out->format = config->format;
4498 out->config.rate = out->sample_rate;
4499 out->config.channels =
4500 audio_channel_count_from_out_mask(out->channel_mask);
4501 if (out->format != audio_format_from_pcm_format(out->config.format)) {
4502 out->config.format = pcm_format_from_audio_format(out->format);
4506 if ((config->sample_rate != 0 && config->sample_rate != out->sample_rate) ||
4507 (config->format != AUDIO_FORMAT_DEFAULT && config->format != out->format) ||
4508 (config->channel_mask != AUDIO_CHANNEL_NONE && config->channel_mask != out->channel_mask)) {
4511 config->sample_rate = out->sample_rate;
4512 config->format = out->format;
4513 config->channel_mask = out->channel_mask;
4518 ALOGV("%s: Usecase(%s) config->format %#x out->config.format %#x\n",
4519 __func__, use_case_table[out->usecase], config->format, out->config.format);
4523 adev->primary_output = out;
4533 if (get_usecase_from_list(adev, out->usecase) != NULL) {
4534 ALOGE("%s: Usecase (%d) is already present", __func__, out->usecase);
4541 out->stream.common.get_sample_rate = out_get_sample_rate;
4542 out->stream.common.set_sample_rate = out_set_sample_rate;
4543 out->stream.common.get_buffer_size = out_get_buffer_size;
4544 out->stream.common.get_channels = out_get_channels;
4545 out->stream.common.get_format = out_get_format;
4546 out->stream.common.set_format = out_set_format;
4547 out->stream.common.standby = out_standby;
4548 out->stream.common.dump = out_dump;
4549 out->stream.common.set_parameters = out_set_parameters;
4550 out->stream.common.get_parameters = out_get_parameters;
4551 out->stream.common.add_audio_effect = out_add_audio_effect;
4552 out->stream.common.remove_audio_effect = out_remove_audio_effect;
4553 out->stream.get_latency = out_get_latency;
4554 out->stream.set_volume = out_set_volume;
4556 out->stream.write = out_write_for_no_output;
4558 out->stream.write = out_write;
4560 out->stream.get_render_position = out_get_render_position;
4561 out->stream.get_next_write_timestamp = out_get_next_write_timestamp;
4562 out->stream.get_presentation_position = out_get_presentation_position;
4564 if (out->realtime)
4565 out->af_period_multiplier = af_period_multiplier;
4567 out->af_period_multiplier = 1;
4569 out->standby = 1;
4570 /* out->muted = false; by calloc() */
4571 /* out->written = 0; by calloc() */
4573 pthread_mutex_init(&out->lock, (const pthread_mutexattr_t *) NULL);
4574 pthread_mutex_init(&out->pre_lock, (const pthread_mutexattr_t *) NULL);
4575 pthread_cond_init(&out->cond, (const pthread_condattr_t *) NULL);
4577 config->format = out->stream.common.get_format(&out->stream.common);
4578 config->channel_mask = out->stream.common.get_channels(&out->stream.common);
4579 config->sample_rate = out->stream.common.get_sample_rate(&out->stream.common);
4581 register_format(out->format, out->supported_formats);
4582 register_channel_mask(out->channel_mask, out->supported_channel_masks);
4583 register_sample_rate(out->sample_rate, out->supported_sample_rates);
4585 out->error_log = error_log_create(
4594 lock_output_stream(out);
4595 audio_extn_snd_mon_register_listener(out, out_snd_mon_cb);
4597 out->card_status = adev->card_status;
4599 pthread_mutex_unlock(&out->lock);
4601 stream_app_type_cfg_init(&out->app_type_cfg);
4603 *stream_out = &out->stream;
4609 free(out);
4618 struct stream_out *out = (struct stream_out *)stream;
4619 struct audio_device *adev = out->dev;
4625 audio_extn_snd_mon_unregister_listener(out);
4627 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
4628 destroy_offload_callback_thread(out);
4630 if (out->compr_config.codec != NULL)
4631 free(out->compr_config.codec);
4634 out->a2dp_compress_mute = false;
4636 if (adev->voice_tx_output == out)
4639 error_log_destroy(out->error_log);
4640 out->error_log = NULL;
4642 pthread_cond_destroy(&out->cond);
4643 pthread_mutex_destroy(&out->pre_lock);
4644 pthread_mutex_destroy(&out->lock);
4770 lock_output_stream(usecase->stream.out);
4776 pthread_mutex_unlock(&usecase->stream.out->lock);
5319 struct stream_out out;
5346 memset(&out, 0, sizeof(out));
5347 out.devices = audio_device; /* only field needed in select_devices */
5348 uc_info.stream.out = &out;
5354 /* select device - similar to start_(in/out)put_stream() */
5369 /* deselect device - similar to stop_(in/out)put_stream() */
5460 /* out and adev lock held */
5461 static int check_a2dp_restore_l(struct audio_device *adev, struct stream_out *out, bool restore)
5468 uc_info = get_usecase_from_list(adev, out->usecase);
5471 __func__, out->usecase);
5476 out->usecase, use_case_table[out->usecase]);
5480 if ((out->devices & AUDIO_DEVICE_OUT_ALL_A2DP) &&
5484 pthread_mutex_lock(&out->compr_mute_lock);
5485 if ((out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) &&
5486 (out->a2dp_compress_mute)) {
5487 out->a2dp_compress_mute = false;
5488 set_compr_volume(&out->stream, out->volume_l, out->volume_r);
5490 pthread_mutex_unlock(&out->compr_mute_lock);
5494 pthread_mutex_lock(&out->compr_mute_lock);
5495 if ((out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) &&
5496 (!out->a2dp_compress_mute)) {
5497 if (!out->standby) {
5499 devices = out->devices;
5500 out->devices = AUDIO_DEVICE_OUT_SPEAKER;
5501 left_p = out->volume_l;
5502 right_p = out->volume_r;
5503 if (out->offload_state == OFFLOAD_STATE_PLAYING)
5504 compress_pause(out->compr);
5505 set_compr_volume(&out->stream, 0.0f, 0.0f);
5506 out->a2dp_compress_mute = true;
5507 select_devices(adev, out->usecase);
5508 if (out->offload_state == OFFLOAD_STATE_PLAYING)
5509 compress_resume(out->compr);
5510 out->devices = devices;
5511 out->volume_l = left_p;
5512 out->volume_r = right_p;
5515 pthread_mutex_unlock(&out->compr_mute_lock);
5521 int check_a2dp_restore(struct audio_device *adev, struct stream_out *out, bool restore)
5525 lock_output_stream(out);
5528 ret = check_a2dp_restore_l(adev, out, restore);
5531 pthread_mutex_unlock(&out->lock);