Lines Matching defs:out
260 static void register_out_stream(struct stream_out *out)
262 struct audio_device *adev = out->dev;
263 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD)
270 out->handle,
271 out->flags);
276 if (out->realtime) {
278 out->handle,
279 out->pcm, &out->config);
304 static void request_out_focus(struct stream_out *out, long ns)
306 struct audio_device *adev = out->dev;
308 if (out->routing_change) {
309 out->routing_change = false;
311 adev->adm_on_routing_change(adev->adm_data, out->handle);
315 adev->adm_request_focus_v2(adev->adm_data, out->handle, ns);
317 adev->adm_request_focus(adev->adm_data, out->handle);
338 static void release_out_focus(struct stream_out *out, long ns __unused)
340 struct audio_device *adev = out->dev;
343 adev->adm_abandon_focus(adev->adm_data, out->handle);
751 static int read_hdmi_channel_masks(struct stream_out *out)
754 int channels = platform_edid_get_max_channels(out->dev->platform);
763 out->supported_channel_masks[0] = AUDIO_CHANNEL_OUT_5POINT1;
767 out->supported_channel_masks[0] = AUDIO_CHANNEL_OUT_5POINT1;
768 out->supported_channel_masks[1] = AUDIO_CHANNEL_OUT_7POINT1;
828 usecase->stream.out->devices);
829 in_snd_device = platform_get_input_snd_device(adev->platform, usecase->stream.out->devices);
830 usecase->devices = usecase->stream.out->devices;
857 usecase->devices = usecase->stream.out->devices;
861 usecase->stream.out->devices);
862 if (usecase->stream.out == adev->primary_output &&
1143 void lock_output_stream(struct stream_out *out)
1145 pthread_mutex_lock(&out->pre_lock);
1146 pthread_mutex_lock(&out->lock);
1147 pthread_mutex_unlock(&out->pre_lock);
1150 /* must be called with out->lock locked */
1151 static int send_offload_cmd_l(struct stream_out* out, int command)
1158 list_add_tail(&out->offload_cmd_list, &cmd->node);
1159 pthread_cond_signal(&out->offload_cond);
1163 /* must be called iwth out->lock locked */
1164 static void stop_compressed_output_l(struct stream_out *out)
1166 out->offload_state = OFFLOAD_STATE_IDLE;
1167 out->playback_started = 0;
1168 out->send_new_metadata = 1;
1169 if (out->compr != NULL) {
1170 compress_stop(out->compr);
1171 while (out->offload_thread_blocked) {
1172 pthread_cond_wait(&out->cond, &out->lock);
1179 struct stream_out *out = (struct stream_out *) context;
1182 out->offload_state = OFFLOAD_STATE_IDLE;
1183 out->playback_started = 0;
1190 lock_output_stream(out);
1196 ALOGVV("%s offload_cmd_list %d out->offload_state %d",
1197 __func__, list_empty(&out->offload_cmd_list),
1198 out->offload_state);
1199 if (list_empty(&out->offload_cmd_list)) {
1201 pthread_cond_wait(&out->offload_cond, &out->lock);
1206 item = list_head(&out->offload_cmd_list);
1210 ALOGVV("%s STATE %d CMD %d out->compr %p",
1211 __func__, out->offload_state, cmd->cmd, out->compr);
1218 if (out->compr == NULL) {
1221 pthread_cond_signal(&out->cond);
1224 out->offload_thread_blocked = true;
1225 pthread_mutex_unlock(&out->lock);
1229 compress_wait(out->compr, -1);
1234 compress_next_track(out->compr);
1235 compress_partial_drain(out->compr);
1239 out->send_new_metadata = 1;
1242 compress_drain(out->compr);
1254 lock_output_stream(out);
1255 out->offload_thread_blocked = false;
1256 pthread_cond_signal(&out->cond);
1259 out->offload_callback(event, NULL, out->offload_cookie);
1264 pthread_cond_signal(&out->cond);
1265 while (!list_empty(&out->offload_cmd_list)) {
1266 item = list_head(&out->offload_cmd_list);
1270 pthread_mutex_unlock(&out->lock);
1275 static int create_offload_callback_thread(struct stream_out *out)
1277 pthread_cond_init(&out->offload_cond, (const pthread_condattr_t *) NULL);
1278 list_init(&out->offload_cmd_list);
1279 pthread_create(&out->offload_thread, (const pthread_attr_t *) NULL,
1280 offload_thread_loop, out);
1284 static int destroy_offload_callback_thread(struct stream_out *out)
1286 lock_output_stream(out);
1287 stop_compressed_output_l(out);
1288 send_offload_cmd_l(out, OFFLOAD_CMD_EXIT);
1290 pthread_mutex_unlock(&out->lock);
1291 pthread_join(out->offload_thread, (void **) NULL);
1292 pthread_cond_destroy(&out->offload_cond);
1374 static int stop_output_stream(struct stream_out *out)
1378 struct audio_device *adev = out->dev;
1381 out->usecase, use_case_table[out->usecase]);
1382 uc_info = get_usecase_from_list(adev, out->usecase);
1385 __func__, out->usecase);
1389 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1391 adev->visualizer_stop_output(out->handle, out->pcm_device_id);
1393 adev->offload_effects_stop_output(out->handle, out->pcm_device_id);
1408 if (out->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL)
1415 int start_output_stream(struct stream_out *out)
1419 struct audio_device *adev = out->dev;
1422 __func__, out->usecase, use_case_table[out->usecase], out->devices);
1424 if (out->card_status == CARD_STATUS_OFFLINE ||
1426 ALOGW("out->card_status or adev->card_status offline, try again");
1431 out->pcm_device_id = platform_get_pcm_device_id(out->usecase, PCM_PLAYBACK);
1432 if (out->pcm_device_id < 0) {
1434 __func__, out->pcm_device_id, out->usecase);
1440 uc_info->id = out->usecase;
1442 uc_info->stream.out = out;
1443 uc_info->devices = out->devices;
1448 if (out->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL)
1449 check_and_set_hdmi_channels(adev, out->config.channels);
1455 select_devices(adev, out->usecase);
1460 __func__, adev->snd_card, out->pcm_device_id, out->config.format);
1461 if (out->usecase != USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1465 if (out->usecase == USECASE_AUDIO_PLAYBACK_AFE_PROXY) {
1468 } else if (out->realtime) {
1474 out->pcm = pcm_open(adev->snd_card, out->pcm_device_id,
1475 flags, &out->config);
1476 if (out->pcm == NULL || !pcm_is_ready(out->pcm)) {
1477 ALOGE("%s: %s", __func__, pcm_get_error(out->pcm));
1478 if (out->pcm != NULL) {
1479 pcm_close(out->pcm);
1480 out->pcm = NULL;
1492 if (pcm_is_ready(out->pcm)) {
1493 ret = pcm_prepare(out->pcm);
1496 pcm_close(out->pcm);
1497 out->pcm = NULL;
1502 out->pcm = NULL;
1503 out->compr = compress_open(adev->snd_card, out->pcm_device_id,
1504 COMPRESS_IN, &out->compr_config);
1505 if (out->compr && !is_compress_ready(out->compr)) {
1506 ALOGE("%s: %s", __func__, compress_get_error(out->compr));
1507 compress_close(out->compr);
1508 out->compr = NULL;
1512 if (out->offload_callback)
1513 compress_nonblock(out->compr, out->non_blocking);
1516 adev->visualizer_start_output(out->handle, out->pcm_device_id);
1518 adev->offload_effects_start_output(out->handle, out->pcm_device_id);
1521 if (out->realtime) {
1522 ret = pcm_start(out->pcm);
1525 pcm_close(out->pcm);
1526 out->pcm = NULL;
1530 register_out_stream(out);
1536 stop_output_stream(out);
1604 struct stream_out *out = (struct stream_out *)stream;
1606 return out->sample_rate;
1616 struct stream_out *out = (struct stream_out *)stream;
1618 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1619 return out->compr_config.fragment_size;
1621 return out->config.period_size * out->af_period_multiplier *
1627 struct stream_out *out = (struct stream_out *)stream;
1629 return out->channel_mask;
1634 struct stream_out *out = (struct stream_out *)stream;
1636 return out->format;
1646 struct stream_out *out = (struct stream_out *)stream;
1647 struct audio_device *adev = out->dev;
1650 out->usecase, use_case_table[out->usecase]);
1652 lock_output_stream(out);
1653 if (!out->standby) {
1655 adev->adm_deregister_stream(adev->adm_data, out->handle);
1658 out->standby = true;
1659 if (out->usecase != USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1660 if (out->pcm) {
1661 pcm_close(out->pcm);
1662 out->pcm = NULL;
1665 stop_compressed_output_l(out);
1666 out->gapless_mdata.encoder_delay = 0;
1667 out->gapless_mdata.encoder_padding = 0;
1668 if (out->compr != NULL) {
1669 compress_close(out->compr);
1670 out->compr = NULL;
1673 stop_output_stream(out);
1676 pthread_mutex_unlock(&out->lock);
1683 struct stream_out *out = (struct stream_out *)stream;
1684 struct audio_device *adev = out->dev;
1687 lock_output_stream(out);
1688 if (!out->standby) {
1689 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1690 stop_compressed_output_l(out);
1691 send_offload_cmd_l(out, OFFLOAD_CMD_ERROR);
1695 pthread_mutex_unlock(&out->lock);
1698 return out_standby(&out->stream.common);
1708 static int parse_compress_metadata(struct stream_out *out, struct str_parms *parms)
1714 if (!out || !parms) {
1732 out->gapless_mdata = tmp_mdata;
1733 out->send_new_metadata = 1;
1735 out->gapless_mdata.encoder_delay, out->gapless_mdata.encoder_padding);
1740 static bool output_drives_call(struct audio_device *adev, struct stream_out *out)
1742 return out == adev->primary_output || out == adev->voice_tx_output;
1747 struct stream_out *out = (struct stream_out *)stream;
1748 struct audio_device *adev = out->dev;
1758 __func__, out->usecase, use_case_table[out->usecase], kvpairs);
1763 lock_output_stream(out);
1773 if (out->devices == AUDIO_DEVICE_OUT_AUX_DIGITAL &&
1798 bool same_dev = out->devices == new_dev;
1799 out->devices = new_dev;
1801 if (output_drives_call(adev, out)) {
1804 adev->current_call_output = out;
1808 adev->current_call_output = out;
1813 if (!out->standby) {
1816 out->routing_change = true;
1818 select_devices(adev, out->usecase);
1824 pthread_mutex_unlock(&out->lock);
1830 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1831 parse_compress_metadata(out, parms);
1841 struct stream_out *out = (struct stream_out *)stream;
1854 while (out->supported_channel_masks[i] != 0) {
1856 if (out_channels_name_to_enum_table[j].value == out->supported_channel_masks[i]) {
1881 struct stream_out *out = (struct stream_out *)stream;
1883 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD)
1885 else if (out->realtime) {
1888 period_ms = (out->af_period_multiplier * out->config.period_size *
1889 1000) / (out->config.rate);
1890 hw_delay = platform_render_latency(out->usecase)/1000;
1894 return (out->config.period_count * out->config.period_size * 1000) /
1895 (out->config.rate);
1901 struct stream_out *out = (struct stream_out *)stream;
1904 if (out->usecase == USECASE_AUDIO_PLAYBACK_MULTI_CH) {
1906 out->muted = (left == 0.0f);
1908 } else if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1910 out->dev;
1915 int pcm_device_id = platform_get_pcm_device_id(out->usecase,
1942 struct stream_out *out = (struct stream_out *)stream;
1943 struct audio_device *adev = out->dev;
1957 lock_output_stream(out);
1958 if (out->card_status != status)
1959 out->card_status = status;
1960 pthread_mutex_unlock(&out->lock);
1963 use_case_table[out->usecase],
1976 struct stream_out *out = (struct stream_out *)stream;
1981 lock_output_stream(out);
1982 usleep(bytes * 1000000 / audio_stream_out_frame_size(&out->stream.common) /
1983 out_get_sample_rate(&out->stream.common));
1984 pthread_mutex_unlock(&out->lock);
1992 struct stream_out *out = (struct stream_out *)stream;
1993 struct audio_device *adev = out->dev;
1996 lock_output_stream(out);
1997 if (out->standby) {
1998 out->standby = false;
2000 ret = start_output_stream(out);
2004 out->standby = true;
2014 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2016 if (out->send_new_metadata) {
2018 compress_set_gapless_metadata(out->compr, &out->gapless_mdata);
2019 out->send_new_metadata = 0;
2023 ret = compress_get_hpointer(out->compr, &avail, &tstamp);
2034 ret = compress_write(out->compr, buffer, avail);
2040 send_offload_cmd_l(out, OFFLOAD_CMD_WAIT_FOR_BUFFER);
2042 if (ret > 0 && !out->playback_started) {
2043 compress_start(out->compr);
2044 out->playback_started = 1;
2045 out->offload_state = OFFLOAD_STATE_PLAYING;
2047 pthread_mutex_unlock(&out->lock);
2050 if (out->pcm) {
2051 if (out->muted)
2056 long ns = pcm_bytes_to_frames(out->pcm, bytes)*1000000000LL/
2057 out->config.rate;
2058 request_out_focus(out, ns);
2060 bool use_mmap = is_mmap_usecase(out->usecase) || out->realtime;
2062 ret = pcm_mmap_write(out->pcm, (void *)buffer, bytes);
2064 ret = pcm_write(out->pcm, (void *)buffer, bytes);
2067 out->written += bytes / (out->config.channels * sizeof(short));
2069 release_out_focus(out, ns);
2074 pthread_mutex_unlock(&out->lock);
2077 out_on_error(&out->stream.common);
2078 if (out->pcm)
2079 ALOGE("%s: error %zu - %s", __func__, ret, pcm_get_error(out->pcm));
2080 if (out->usecase != USECASE_AUDIO_PLAYBACK_OFFLOAD)
2082 out_get_sample_rate(&out->stream.common));
2090 struct stream_out *out = (struct stream_out *)stream;
2092 if ((out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) && (dsp_frames != NULL)) {
2093 lock_output_stream(out);
2094 if (out->compr != NULL) {
2097 compress_get_tstamp(out->compr, &frames, &out->sample_rate);
2100 __func__, *dsp_frames, out->sample_rate);
2102 pthread_mutex_unlock(&out->lock);
2129 struct stream_out *out = (struct stream_out *)stream;
2133 lock_output_stream(out);
2135 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2136 if (out->compr != NULL) {
2138 compress_get_tstamp(out->compr, &dsp_frames,
2139 &out->sample_rate);
2141 __func__, dsp_frames, out->sample_rate);
2148 if (out->pcm) {
2150 if (pcm_get_htimestamp(out->pcm, &avail, timestamp) == 0) {
2151 size_t kernel_buffer_size = out->config.period_size * out->config.period_count;
2152 int64_t signed_frames = out->written - kernel_buffer_size + avail;
2156 (platform_render_latency(out->usecase) * out->sample_rate / 1000000LL);
2167 pthread_mutex_unlock(&out->lock);
2175 struct stream_out *out = (struct stream_out *)stream;
2178 lock_output_stream(out);
2179 out->offload_callback = callback;
2180 out->offload_cookie = cookie;
2181 pthread_mutex_unlock(&out->lock);
2187 struct stream_out *out = (struct stream_out *)stream;
2190 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2191 lock_output_stream(out);
2192 if (out->compr != NULL && out->offload_state == OFFLOAD_STATE_PLAYING) {
2193 status = compress_pause(out->compr);
2194 out->offload_state = OFFLOAD_STATE_PAUSED;
2196 pthread_mutex_unlock(&out->lock);
2203 struct stream_out *out = (struct stream_out *)stream;
2206 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2208 lock_output_stream(out);
2209 if (out->compr != NULL && out->offload_state == OFFLOAD_STATE_PAUSED) {
2210 status = compress_resume(out->compr);
2211 out->offload_state = OFFLOAD_STATE_PLAYING;
2213 pthread_mutex_unlock(&out->lock);
2220 struct stream_out *out = (struct stream_out *)stream;
2223 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2224 lock_output_stream(out);
2226 status = send_offload_cmd_l(out, OFFLOAD_CMD_PARTIAL_DRAIN);
2228 status = send_offload_cmd_l(out, OFFLOAD_CMD_DRAIN);
2229 pthread_mutex_unlock(&out->lock);
2236 struct stream_out *out = (struct stream_out *)stream;
2238 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2239 lock_output_stream(out);
2240 stop_compressed_output_l(out);
2241 pthread_mutex_unlock(&out->lock);
2610 struct stream_out *out;
2616 out = (struct stream_out *)calloc(1, sizeof(struct stream_out));
2621 out->flags = flags;
2622 out->devices = devices;
2623 out->dev = adev;
2624 out->format = config->format;
2625 out->sample_rate = config->sample_rate;
2626 out->channel_mask = AUDIO_CHANNEL_OUT_STEREO;
2627 out->supported_channel_masks[0] = AUDIO_CHANNEL_OUT_STEREO;
2628 out->handle = handle;
2631 if (out->flags & AUDIO_OUTPUT_FLAG_DIRECT &&
2632 !(out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) &&
2633 out->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL) {
2635 ret = read_hdmi_channel_masks(out);
2647 out->channel_mask = config->channel_mask;
2648 out->sample_rate = config->sample_rate;
2649 out->format = config->format;
2650 out->usecase = USECASE_AUDIO_PLAYBACK_MULTI_CH;
2651 out->config = pcm_config_hdmi_multi;
2652 out->config.rate = config->sample_rate;
2653 out->config.channels = audio_channel_count_from_out_mask(out->channel_mask);
2654 out->config.period_size = HDMI_MULTI_PERIOD_BYTES / (out->config.channels * 2);
2655 } else if (out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) {
2679 out->compr_config.codec = (struct snd_codec *)
2682 out->usecase = USECASE_AUDIO_PLAYBACK_OFFLOAD;
2684 out->channel_mask = config->offload_info.channel_mask;
2686 out->channel_mask = config->channel_mask;
2687 out->format = config->offload_info.format;
2688 out->sample_rate = config->offload_info.sample_rate;
2690 out->stream.set_callback = out_set_callback;
2691 out->stream.pause = out_pause;
2692 out->stream.resume = out_resume;
2693 out->stream.drain = out_drain;
2694 out->stream.flush = out_flush;
2696 out->compr_config.codec->id =
2698 out->compr_config.fragment_size = COMPRESS_OFFLOAD_FRAGMENT_SIZE;
2699 out->compr_config.fragments = COMPRESS_OFFLOAD_NUM_FRAGMENTS;
2700 out->compr_config.codec->sample_rate = config->offload_info.sample_rate;
2701 out->compr_config.codec->bit_rate =
2703 out->compr_config.codec->ch_in =
2705 out->compr_config.codec->ch_out = out->compr_config.codec->ch_in;
2708 out->non_blocking = 1;
2710 out->send_new_metadata = 1;
2711 create_offload_callback_thread(out);
2715 } else if (out->devices == AUDIO_DEVICE_OUT_TELEPHONY_TX) {
2724 out->sample_rate = config->sample_rate;
2725 out->config.rate = config->sample_rate;
2733 out->format = config->format;
2734 out->usecase = USECASE_AUDIO_PLAYBACK_AFE_PROXY;
2735 out->config = pcm_config_afe_proxy_playback;
2736 adev->voice_tx_output = out;
2738 if (out->flags & AUDIO_OUTPUT_FLAG_DEEP_BUFFER) {
2739 out->usecase = USECASE_AUDIO_PLAYBACK_DEEP_BUFFER;
2740 out->config = pcm_config_deep_buffer;
2741 } else if (out->flags & AUDIO_OUTPUT_FLAG_TTS) {
2742 out->usecase = USECASE_AUDIO_PLAYBACK_TTS;
2743 out->config = pcm_config_deep_buffer;
2744 } else if (out->flags & AUDIO_OUTPUT_FLAG_RAW) {
2745 out->usecase = USECASE_AUDIO_PLAYBACK_ULL;
2746 out->realtime = may_use_noirq_mode(adev, USECASE_AUDIO_PLAYBACK_ULL, out->flags);
2747 out->usecase = USECASE_AUDIO_PLAYBACK_ULL;
2748 out->config = out->realtime ? pcm_config_rt : pcm_config_low_latency;
2750 out->usecase = USECASE_AUDIO_PLAYBACK_LOW_LATENCY;
2751 out->config = pcm_config_low_latency;
2753 if (config->format != audio_format_from_pcm_format(out->config.format)) {
2755 && pcm_params_format_test(adev->use_case_table[out->usecase],
2757 out->config.format = pcm_format_from_audio_format(config->format);
2758 /* out->format already set to config->format */
2762 * Note: out->format is returned by out->stream.common.get_format()
2765 out->format = audio_format_from_pcm_format(out->config.format);
2768 out->sample_rate = out->config.rate;
2770 ALOGV("%s: Usecase(%s) config->format %#x out->config.format %#x\n",
2771 __func__, use_case_table[out->usecase], config->format, out->config.format);
2775 adev->primary_output = out;
2785 if (get_usecase_from_list(adev, out->usecase) != NULL) {
2786 ALOGE("%s: Usecase (%d) is already present", __func__, out->usecase);
2793 out->stream.common.get_sample_rate = out_get_sample_rate;
2794 out->stream.common.set_sample_rate = out_set_sample_rate;
2795 out->stream.common.get_buffer_size = out_get_buffer_size;
2796 out->stream.common.get_channels = out_get_channels;
2797 out->stream.common.get_format = out_get_format;
2798 out->stream.common.set_format = out_set_format;
2799 out->stream.common.standby = out_standby;
2800 out->stream.common.dump = out_dump;
2801 out->stream.common.set_parameters = out_set_parameters;
2802 out->stream.common.get_parameters = out_get_parameters;
2803 out->stream.common.add_audio_effect = out_add_audio_effect;
2804 out->stream.common.remove_audio_effect = out_remove_audio_effect;
2805 out->stream.get_latency = out_get_latency;
2806 out->stream.set_volume = out_set_volume;
2808 out->stream.write = out_write_for_no_output;
2810 out->stream.write = out_write;
2812 out->stream.get_render_position = out_get_render_position;
2813 out->stream.get_next_write_timestamp = out_get_next_write_timestamp;
2814 out->stream.get_presentation_position = out_get_presentation_position;
2816 out->af_period_multiplier = out->realtime ? af_period_multiplier : 1;
2817 out->standby = 1;
2818 /* out->muted = false; by calloc() */
2819 /* out->written = 0; by calloc() */
2821 pthread_mutex_init(&out->lock, (const pthread_mutexattr_t *) NULL);
2822 pthread_mutex_init(&out->pre_lock, (const pthread_mutexattr_t *) NULL);
2823 pthread_cond_init(&out->cond, (const pthread_condattr_t *) NULL);
2825 config->format = out->stream.common.get_format(&out->stream.common);
2826 config->channel_mask = out->stream.common.get_channels(&out->stream.common);
2827 config->sample_rate = out->stream.common.get_sample_rate(&out->stream.common);
2835 lock_output_stream(out);
2836 audio_extn_snd_mon_register_listener(out, out_snd_mon_cb);
2838 out->card_status = adev->card_status;
2840 pthread_mutex_unlock(&out->lock);
2842 *stream_out = &out->stream;
2847 free(out);
2856 struct stream_out *out = (struct stream_out *)stream;
2857 struct audio_device *adev = out->dev;
2863 audio_extn_snd_mon_unregister_listener(out);
2865 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2866 destroy_offload_callback_thread(out);
2868 if (out->compr_config.codec != NULL)
2869 free(out->compr_config.codec);
2872 if (adev->voice_tx_output == out)
2875 pthread_cond_destroy(&out->cond);
2876 pthread_mutex_destroy(&out->lock);
3311 struct stream_out out;
3338 memset(&out, 0, sizeof(out));
3339 out.devices = audio_device; /* only field needed in select_devices */
3340 uc_info.stream.out = &out;
3346 /* select device - similar to start_(in/out)put_stream() */
3361 /* deselect device - similar to stop_(in/out)put_stream() */
