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);
756 audio_devices_t a1 = uc->stream.out->devices;
757 audio_devices_t a2 = new_uc->stream.out->devices;
939 static int read_hdmi_channel_masks(struct stream_out *out)
942 int channels = platform_edid_get_max_channels(out->dev->platform);
951 out->supported_channel_masks[0] = AUDIO_CHANNEL_OUT_5POINT1;
955 out->supported_channel_masks[0] = AUDIO_CHANNEL_OUT_5POINT1;
956 out->supported_channel_masks[1] = AUDIO_CHANNEL_OUT_7POINT1;
1016 usecase->stream.out->devices);
1017 in_snd_device = platform_get_input_snd_device(adev->platform, usecase->stream.out->devices);
1018 usecase->devices = usecase->stream.out->devices;
1045 usecase->devices = usecase->stream.out->devices;
1049 usecase->stream.out->devices);
1050 if (usecase->stream.out == adev->primary_output &&
1331 void lock_output_stream(struct stream_out *out)
1333 pthread_mutex_lock(&out->pre_lock);
1334 pthread_mutex_lock(&out->lock);
1335 pthread_mutex_unlock(&out->pre_lock);
1338 /* must be called with out->lock locked */
1339 static int send_offload_cmd_l(struct stream_out* out, int command)
1346 list_add_tail(&out->offload_cmd_list, &cmd->node);
1347 pthread_cond_signal(&out->offload_cond);
1351 /* must be called iwth out->lock locked */
1352 static void stop_compressed_output_l(struct stream_out *out)
1354 out->offload_state = OFFLOAD_STATE_IDLE;
1355 out->playback_started = 0;
1356 out->send_new_metadata = 1;
1357 if (out->compr != NULL) {
1358 compress_stop(out->compr);
1359 while (out->offload_thread_blocked) {
1360 pthread_cond_wait(&out->cond, &out->lock);
1367 struct stream_out *out = (struct stream_out *) context;
1370 out->offload_state = OFFLOAD_STATE_IDLE;
1371 out->playback_started = 0;
1378 lock_output_stream(out);
1384 ALOGVV("%s offload_cmd_list %d out->offload_state %d",
1385 __func__, list_empty(&out->offload_cmd_list),
1386 out->offload_state);
1387 if (list_empty(&out->offload_cmd_list)) {
1389 pthread_cond_wait(&out->offload_cond, &out->lock);
1394 item = list_head(&out->offload_cmd_list);
1398 ALOGVV("%s STATE %d CMD %d out->compr %p",
1399 __func__, out->offload_state, cmd->cmd, out->compr);
1406 if (out->compr == NULL) {
1409 pthread_cond_signal(&out->cond);
1412 out->offload_thread_blocked = true;
1413 pthread_mutex_unlock(&out->lock);
1417 out->compr, -1);
1422 compress_next_track(out->compr);
1423 compress_partial_drain(out->compr);
1427 out->send_new_metadata = 1;
1430 compress_drain(out->compr);
1442 lock_output_stream(out);
1443 out->offload_thread_blocked = false;
1444 pthread_cond_signal(&out->cond);
1447 out->offload_callback(event, NULL, out->offload_cookie);
1452 pthread_cond_signal(&out->cond);
1453 while (!list_empty(&out->offload_cmd_list)) {
1454 item = list_head(&out->offload_cmd_list);
1458 pthread_mutex_unlock(&out->lock);
1463 static int create_offload_callback_thread(struct stream_out *out)
1465 pthread_cond_init(&out->offload_cond, (const pthread_condattr_t *) NULL);
1466 list_init(&out->offload_cmd_list);
1467 pthread_create(&out->offload_thread, (const pthread_attr_t *) NULL,
1468 offload_thread_loop, out);
1472 static int destroy_offload_callback_thread(struct stream_out *out)
1474 lock_output_stream(out);
1475 stop_compressed_output_l(out);
1476 send_offload_cmd_l(out, OFFLOAD_CMD_EXIT);
1478 pthread_mutex_unlock(&out->lock);
1479 pthread_join(out->offload_thread, (void **) NULL);
1480 pthread_cond_destroy(&out->offload_cond);
1562 static int stop_output_stream(struct stream_out *out)
1566 struct audio_device *adev = out->dev;
1569 out->usecase, use_case_table[out->usecase]);
1570 uc_info = get_usecase_from_list(adev, out->usecase);
1573 __func__, out->usecase);
1577 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1579 adev->visualizer_stop_output(out->handle, out->pcm_device_id);
1581 adev->offload_effects_stop_output(out->handle, out->pcm_device_id);
1596 if (out->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL)
1603 int start_output_stream(struct stream_out *out)
1607 struct audio_device *adev = out->dev;
1610 __func__, out->usecase, use_case_table[out->usecase], out->devices);
1612 if (out->card_status == CARD_STATUS_OFFLINE ||
1614 ALOGW("out->card_status or adev->card_status offline, try again");
1619 out->pcm_device_id = platform_get_pcm_device_id(out->usecase, PCM_PLAYBACK);
1620 if (out->pcm_device_id < 0) {
1622 __func__, out->pcm_device_id, out->usecase);
1628 uc_info->id = out->usecase;
1630 uc_info->stream.out = out;
1631 uc_info->devices = out->devices;
1636 if (out->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL)
1637 check_and_set_hdmi_channels(adev, out->config.channels);
1643 select_devices(adev, out->usecase);
1648 __func__, adev->snd_card, out->pcm_device_id, out->config.format);
1649 if (out->usecase != USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1653 if (out->usecase == USECASE_AUDIO_PLAYBACK_AFE_PROXY) {
1656 } else if (out->realtime) {
1662 out->pcm = pcm_open(adev->snd_card, out->pcm_device_id,
1663 flags, &out->config);
1664 if (out->pcm == NULL || !pcm_is_ready(out->pcm)) {
1665 ALOGE("%s: %s", __func__, pcm_get_error(out->pcm));
1666 if (out->pcm != NULL) {
1667 pcm_close(out->pcm);
1668 out->pcm = NULL;
1680 if (pcm_is_ready(out->pcm)) {
1681 ret = pcm_prepare(out->pcm);
1684 pcm_close(out->pcm);
1685 out->pcm = NULL;
1690 out->pcm = NULL;
1691 out->compr = compress_open(adev->snd_card, out->pcm_device_id,
1692 COMPRESS_IN, &out->compr_config);
1693 if (out->compr && !is_compress_ready(out->compr)) {
1694 ALOGE("%s: %s", __func__, compress_get_error(out->compr));
1695 compress_close(out->compr);
1696 out->compr = NULL;
1700 if (out->offload_callback)
1701 compress_nonblock(out->compr, out->non_blocking);
1704 adev->visualizer_start_output(out->handle, out->pcm_device_id);
1706 adev->offload_effects_start_output(out->handle, out->pcm_device_id);
1709 if (out->realtime) {
1710 ret = pcm_start(out->pcm);
1713 pcm_close(out->pcm);
1714 out->pcm = NULL;
1718 register_out_stream(out);
1724 stop_output_stream(out);
1792 struct stream_out *out = (struct stream_out *)stream;
1794 return out->sample_rate;
1804 struct stream_out *out = (struct stream_out *)stream;
1806 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1807 return out->compr_config.fragment_size;
1809 return out->config.period_size * out->af_period_multiplier *
1815 struct stream_out *out = (struct stream_out *)stream;
1817 return out->channel_mask;
1822 struct stream_out *out = (struct stream_out *)stream;
1824 return out->format;
1834 struct stream_out *out = (struct stream_out *)stream;
1835 struct audio_device *adev = out->dev;
1838 out->usecase, use_case_table[out->usecase]);
1840 lock_output_stream(out);
1841 if (!out->standby) {
1843 adev->adm_deregister_stream(adev->adm_data, out->handle);
1846 out->standby = true;
1847 if (out->usecase != USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1848 if (out->pcm) {
1849 pcm_close(out->pcm);
1850 out->pcm = NULL;
1853 stop_compressed_output_l(out);
1854 out->gapless_mdata.encoder_delay = 0;
1855 out->gapless_mdata.encoder_padding = 0;
1856 if (out->compr != NULL) {
1857 compress_close(out->compr);
1858 out->compr = NULL;
1861 stop_output_stream(out);
1864 pthread_mutex_unlock(&out->lock);
1871 struct stream_out *out = (struct stream_out *)stream;
1872 struct audio_device *adev = out->dev;
1875 lock_output_stream(out);
1876 if (!out->standby) {
1877 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1878 stop_compressed_output_l(out);
1879 send_offload_cmd_l(out, OFFLOAD_CMD_ERROR);
1883 pthread_mutex_unlock(&out->lock);
1886 return out_standby(&out->stream.common);
1893 struct stream_out *out = (struct stream_out *)stream;
1898 const bool locked = (pthread_mutex_trylock(&out->lock) == 0);
1899 dprintf(fd, " Standby: %s\n", out->standby ? "yes" : "no");
1900 dprintf(fd, " Frames written: %lld\n", (long long)out->written);
1903 log_dump_l(&out->error_log, fd);
1904 pthread_mutex_unlock(&out->lock);
1907 struct error_log log = out->error_log;
1913 static int parse_compress_metadata(struct stream_out *out, struct str_parms *parms)
1919 if (!out || !parms) {
1937 out->gapless_mdata = tmp_mdata;
1938 out->send_new_metadata = 1;
1940 out->gapless_mdata.encoder_delay, out->gapless_mdata.encoder_padding);
1945 static bool output_drives_call(struct audio_device *adev, struct stream_out *out)
1947 return out == adev->primary_output || out == adev->voice_tx_output;
1952 struct stream_out *out = (struct stream_out *)stream;
1953 struct audio_device *adev = out->dev;
1963 __func__, out->usecase, use_case_table[out->usecase], kvpairs);
1968 lock_output_stream(out);
1978 if (out->devices == AUDIO_DEVICE_OUT_AUX_DIGITAL &&
2003 bool same_dev = out->devices == new_dev;
2004 out->devices = new_dev;
2006 if (output_drives_call(adev, out)) {
2009 adev->current_call_output = out;
2013 adev->current_call_output = out;
2018 if (!out->standby) {
2021 out->routing_change = true;
2023 select_devices(adev, out->usecase);
2029 pthread_mutex_unlock(&out->lock);
2035 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2036 parse_compress_metadata(out, parms);
2046 struct stream_out *out = (struct stream_out *)stream;
2059 while (out->supported_channel_masks[i] != 0) {
2061 if (out_channels_name_to_enum_table[j].value == out->supported_channel_masks[i]) {
2086 struct stream_out *out = (struct stream_out *)stream;
2088 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD)
2090 else if (out->realtime) {
2093 period_ms = (out->af_period_multiplier * out->config.period_size *
2094 1000) / (out->config.rate);
2095 hw_delay = platform_render_latency(out->usecase)/1000;
2099 return (out->config.period_count * out->config.period_size * 1000) /
2100 (out->config.rate);
2106 struct stream_out *out = (struct stream_out *)stream;
2109 if (out->usecase == USECASE_AUDIO_PLAYBACK_MULTI_CH) {
2111 out->muted = (left == 0.0f);
2113 } else if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2115 struct audio_device *adev = out->dev;
2120 int pcm_device_id = platform_get_pcm_device_id(out->usecase,
2147 struct stream_out *out = (struct stream_out *)stream;
2148 struct audio_device *adev = out->dev;
2162 lock_output_stream(out);
2163 if (out->card_status != status)
2164 out->card_status = status;
2165 pthread_mutex_unlock(&out->lock);
2168 use_case_table[out->usecase],
2181 struct stream_out *out = (struct stream_out *)stream;
2186 lock_output_stream(out);
2187 usleep(bytes * 1000000 / audio_stream_out_frame_size(&out->stream.common) /
2188 out_get_sample_rate(&out->stream.common));
2189 pthread_mutex_unlock(&out->lock);
2197 struct stream_out *out = (struct stream_out *)stream;
2198 struct audio_device *adev = out->dev;
2202 lock_output_stream(out);
2203 if (out->standby) {
2204 out->standby = false;
2206 ret = start_output_stream(out);
2210 out->standby = true;
2220 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2222 if (out->send_new_metadata) {
2224 compress_set_gapless_metadata(out->compr, &out->gapless_mdata);
2225 out->send_new_metadata = 0;
2229 ret = compress_get_hpointer(out->compr, &avail, &tstamp);
2240 ret = compress_write(out->compr, buffer, avail);
2246 send_offload_cmd_l(out, OFFLOAD_CMD_WAIT_FOR_BUFFER);
2248 if (ret > 0 && !out->playback_started) {
2249 compress_start(out->compr);
2250 out->playback_started = 1;
2251 out->offload_state = OFFLOAD_STATE_PLAYING;
2254 log_error_l(&out->error_log, ERROR_CODE_WRITE);
2256 pthread_mutex_unlock(&out->lock);
2260 if (out->pcm) {
2261 if (out->muted)
2266 long ns = pcm_bytes_to_frames(out->pcm, bytes)*1000000000LL/
2267 out->config.rate;
2268 request_out_focus(out, ns);
2270 bool use_mmap = is_mmap_usecase(out->usecase) || out->realtime;
2272 ret = pcm_mmap_write(out->pcm, (void *)buffer, bytes);
2274 ret = pcm_write(out->pcm, (void *)buffer, bytes);
2276 release_out_focus(out, ns);
2278 LOG_ALWAYS_FATAL("out->pcm is NULL after starting output stream");
2284 if (out->usecase != USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2285 out->written += bytes / (out->config.channels * sizeof(short));
2289 log_error_l(&out->error_log, error_code);
2290 if (out->usecase != USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2291 ALOGE_IF(out->pcm != NULL,
2292 "%s: error %zd - %s", __func__, ret, pcm_get_error(out->pcm));
2294 out_get_sample_rate(&out->stream.common);
2299 pthread_mutex_unlock(&out->lock);
2302 out_on_error(&out->stream.common);
2312 struct stream_out *out = (struct stream_out *)stream;
2314 if ((out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) && (dsp_frames != NULL)) {
2315 lock_output_stream(out);
2316 if (out->compr != NULL) {
2319 compress_get_tstamp(out->compr, &frames, &out->sample_rate);
2322 __func__, *dsp_frames, out->sample_rate);
2324 pthread_mutex_unlock(&out->lock);
2351 struct stream_out *out = (struct stream_out *)stream;
2355 lock_output_stream(out);
2357 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2358 if (out->compr != NULL) {
2360 compress_get_tstamp(out->compr, &dsp_frames,
2361 &out->sample_rate);
2363 __func__, dsp_frames, out->sample_rate);
2370 if (out->pcm) {
2372 if (pcm_get_htimestamp(out->pcm, &avail, timestamp) == 0) {
2373 size_t kernel_buffer_size = out->config.period_size * out->config.period_count;
2374 int64_t signed_frames = out->written - kernel_buffer_size + avail;
2378 (platform_render_latency(out->usecase) * out->sample_rate / 1000000LL);
2389 pthread_mutex_unlock(&out->lock);
2397 struct stream_out *out = (struct stream_out *)stream;
2400 lock_output_stream(out);
2401 out->offload_callback = callback;
2402 out->offload_cookie = cookie;
2403 pthread_mutex_unlock(&out->lock);
2409 struct stream_out *out = (struct stream_out *)stream;
2412 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2413 lock_output_stream(out);
2414 if (out->compr != NULL && out->offload_state == OFFLOAD_STATE_PLAYING) {
2415 status = compress_pause(out->compr);
2416 out->offload_state = OFFLOAD_STATE_PAUSED;
2418 pthread_mutex_unlock(&out->lock);
2425 struct stream_out *out = (struct stream_out *)stream;
2428 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2430 lock_output_stream(out);
2431 if (out->compr != NULL && out->offload_state == OFFLOAD_STATE_PAUSED) {
2432 status = compress_resume(out->compr);
2433 out->offload_state = OFFLOAD_STATE_PLAYING;
2435 pthread_mutex_unlock(&out->lock);
2442 struct stream_out *out = (struct stream_out *)stream;
2445 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2446 lock_output_stream(out);
2448 status = send_offload_cmd_l(out, OFFLOAD_CMD_PARTIAL_DRAIN);
2450 status = send_offload_cmd_l(out, OFFLOAD_CMD_DRAIN);
2451 pthread_mutex_unlock(&out->lock);
2458 struct stream_out *out = (struct stream_out *)stream;
2460 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2461 lock_output_stream(out);
2462 stop_compressed_output_l(out);
2463 pthread_mutex_unlock(&out->lock);
2832 struct stream_out *out;
2838 out = (struct stream_out *)calloc(1, sizeof(struct stream_out));
2843 out->flags = flags;
2844 out->devices = devices;
2845 out->dev = adev;
2846 out->format = config->format;
2847 out->sample_rate = config->sample_rate;
2848 out->channel_mask = AUDIO_CHANNEL_OUT_STEREO;
2849 out->supported_channel_masks[0] = AUDIO_CHANNEL_OUT_STEREO;
2850 out->handle = handle;
2853 if (out->flags & AUDIO_OUTPUT_FLAG_DIRECT &&
2854 !(out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) &&
2855 out->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL) {
2857 ret = read_hdmi_channel_masks(out);
2869 out->channel_mask = config->channel_mask;
2870 out->sample_rate = config->sample_rate;
2871 out->format = config->format;
2872 out->usecase = USECASE_AUDIO_PLAYBACK_MULTI_CH;
2873 out->config = pcm_config_hdmi_multi;
2874 out->config.rate = config->sample_rate;
2875 out->config.channels = audio_channel_count_from_out_mask(out->channel_mask);
2876 out->config.period_size = HDMI_MULTI_PERIOD_BYTES / (out->config.channels * 2);
2877 } else if (out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) {
2901 out->compr_config.codec = (struct snd_codec *)
2904 out->usecase = USECASE_AUDIO_PLAYBACK_OFFLOAD;
2906 out->channel_mask = config->offload_info.channel_mask;
2908 out->channel_mask = config->channel_mask;
2909 out->format = config->offload_info.format;
2910 out->sample_rate = config->offload_info.sample_rate;
2912 out->stream.set_callback = out_set_callback;
2913 out->stream.pause = out_pause;
2914 out->stream.resume = out_resume;
2915 out->stream.drain = out_drain;
2916 out->stream.flush = out_flush;
2918 out->compr_config.codec->id =
2920 out->compr_config.fragment_size = COMPRESS_OFFLOAD_FRAGMENT_SIZE;
2921 out->compr_config.fragments = COMPRESS_OFFLOAD_NUM_FRAGMENTS;
2922 out->compr_config.codec->sample_rate = config->offload_info.sample_rate;
2923 out->compr_config.codec->bit_rate =
2925 out->compr_config.codec->ch_in =
2927 out->compr_config.codec->ch_out = out->compr_config.codec->ch_in;
2930 out->non_blocking = 1;
2932 out->send_new_metadata = 1;
2933 create_offload_callback_thread(out);
2937 } else if (out->devices == AUDIO_DEVICE_OUT_TELEPHONY_TX) {
2946 out->sample_rate = config->sample_rate;
2947 out->config.rate = config->sample_rate;
2955 out->format = config->format;
2956 out->usecase = USECASE_AUDIO_PLAYBACK_AFE_PROXY;
2957 out->config = pcm_config_afe_proxy_playback;
2958 adev->voice_tx_output = out;
2960 if (out->flags & AUDIO_OUTPUT_FLAG_DEEP_BUFFER) {
2961 out->usecase = USECASE_AUDIO_PLAYBACK_DEEP_BUFFER;
2962 out->config = pcm_config_deep_buffer;
2963 } else if (out->flags & AUDIO_OUTPUT_FLAG_TTS) {
2964 out->usecase = USECASE_AUDIO_PLAYBACK_TTS;
2965 out->config = pcm_config_deep_buffer;
2966 } else if (out->flags & AUDIO_OUTPUT_FLAG_RAW) {
2967 out->usecase = USECASE_AUDIO_PLAYBACK_ULL;
2968 out->realtime = may_use_noirq_mode(adev, USECASE_AUDIO_PLAYBACK_ULL, out->flags);
2969 out->usecase = USECASE_AUDIO_PLAYBACK_ULL;
2970 out->config = out->realtime ? pcm_config_rt : pcm_config_low_latency;
2972 out->usecase = USECASE_AUDIO_PLAYBACK_LOW_LATENCY;
2973 out->config = pcm_config_low_latency;
2975 if (config->format != audio_format_from_pcm_format(out->config.format)) {
2977 && pcm_params_format_test(adev->use_case_table[out->usecase],
2979 out->config.format = pcm_format_from_audio_format(config->format);
2980 /* out->format already set to config->format */
2984 * Note: out->format is returned by out->stream.common.get_format()
2987 out->format = audio_format_from_pcm_format(out->config.format);
2990 out->sample_rate = out->config.rate;
2992 ALOGV("%s: Usecase(%s) config->format %#x out->config.format %#x\n",
2993 __func__, use_case_table[out->usecase], config->format, out->config.format);
2997 adev->primary_output = out;
3007 if (get_usecase_from_list(adev, out->usecase) != NULL) {
3008 ALOGE("%s: Usecase (%d) is already present", __func__, out->usecase);
3015 out->stream.common.get_sample_rate = out_get_sample_rate;
3016 out->stream.common.set_sample_rate = out_set_sample_rate;
3017 out->stream.common.get_buffer_size = out_get_buffer_size;
3018 out->stream.common.get_channels = out_get_channels;
3019 out->stream.common.get_format = out_get_format;
3020 out->stream.common.set_format = out_set_format;
3021 out->stream.common.standby = out_standby;
3022 out->stream.common.dump = out_dump;
3023 out->stream.common.set_parameters = out_set_parameters;
3024 out->stream.common.get_parameters = out_get_parameters;
3025 out->stream.common.add_audio_effect = out_add_audio_effect;
3026 out->stream.common.remove_audio_effect = out_remove_audio_effect;
3027 out->stream.get_latency = out_get_latency;
3028 out->stream.set_volume = out_set_volume;
3030 out->stream.write = out_write_for_no_output;
3032 out->stream.write = out_write;
3034 out->stream.get_render_position = out_get_render_position;
3035 out->stream.get_next_write_timestamp = out_get_next_write_timestamp;
3036 out->stream.get_presentation_position = out_get_presentation_position;
3038 out->af_period_multiplier = out->realtime ? af_period_multiplier : 1;
3039 out->standby = 1;
3040 /* out->muted = false; by calloc() */
3041 /* out->written = 0; by calloc() */
3043 pthread_mutex_init(&out->lock, (const pthread_mutexattr_t *) NULL);
3044 pthread_mutex_init(&out->pre_lock, (const pthread_mutexattr_t *) NULL);
3045 pthread_cond_init(&out->cond, (const pthread_condattr_t *) NULL);
3047 config->format = out->stream.common.get_format(&out->stream.common);
3048 config->channel_mask = out->stream.common.get_channels(&out->stream.common);
3049 config->sample_rate = out->stream.common.get_sample_rate(&out->stream.common);
3057 lock_output_stream(out);
3058 audio_extn_snd_mon_register_listener(out, out_snd_mon_cb);
3060 out->card_status = adev->card_status;
3062 pthread_mutex_unlock(&out->lock);
3064 *stream_out = &out->stream;
3069 free(out);
3078 struct stream_out *out = (struct stream_out *)stream;
3079 struct audio_device *adev = out->dev;
3085 audio_extn_snd_mon_unregister_listener(out);
3087 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
3088 destroy_offload_callback_thread(out);
3090 if (out->compr_config.codec != NULL)
3091 free(out->compr_config.codec);
3094 if (adev->voice_tx_output == out)
3097 pthread_cond_destroy(&out->cond);
3098 pthread_mutex_destroy(&out->lock);
3533 struct stream_out out;
3560 memset(&out, 0, sizeof(out));
3561 out.devices = audio_device; /* only field needed in select_devices */
3562 uc_info.stream.out = &out;
3568 /* select device - similar to start_(in/out)put_stream() */
3583 /* deselect device - similar to stop_(in/out)put_stream() */
