Lines Matching defs:out
454 static int read_hdmi_channel_masks(struct stream_out *out)
457 int channels = platform_edid_get_max_channels(out->dev->platform);
466 out->supported_channel_masks[0] = AUDIO_CHANNEL_OUT_5POINT1;
470 out->supported_channel_masks[0] = AUDIO_CHANNEL_OUT_5POINT1;
471 out->supported_channel_masks[1] = AUDIO_CHANNEL_OUT_7POINT1;
531 usecase->stream.out->devices);
532 in_snd_device = platform_get_input_snd_device(adev->platform, usecase->stream.out->devices);
533 usecase->devices = usecase->stream.out->devices;
560 usecase->devices = usecase->stream.out->devices;
564 usecase->stream.out->devices);
565 if (usecase->stream.out == adev->primary_output &&
765 /* must be called with out->lock locked */
766 static int send_offload_cmd_l(struct stream_out* out, int command)
773 list_add_tail(&out->offload_cmd_list, &cmd->node);
774 pthread_cond_signal(&out->offload_cond);
778 /* must be called iwth out->lock locked */
779 static void stop_compressed_output_l(struct stream_out *out)
781 out->offload_state = OFFLOAD_STATE_IDLE;
782 out->playback_started = 0;
783 out->send_new_metadata = 1;
784 if (out->compr != NULL) {
785 compress_stop(out->compr);
786 while (out->offload_thread_blocked) {
787 pthread_cond_wait(&out->cond, &out->lock);
794 struct stream_out *out = (struct stream_out *) context;
797 out->offload_state = OFFLOAD_STATE_IDLE;
798 out->playback_started = 0;
805 pthread_mutex_lock(&out->lock);
811 ALOGVV("%s offload_cmd_list %d out->offload_state %d",
812 __func__, list_empty(&out->offload_cmd_list),
813 out->offload_state);
814 if (list_empty(&out->offload_cmd_list)) {
816 pthread_cond_wait(&out->offload_cond, &out->lock);
821 item = list_head(&out->offload_cmd_list);
825 ALOGVV("%s STATE %d CMD %d out->compr %p",
826 __func__, out->offload_state, cmd->cmd, out->compr);
833 if (out->compr == NULL) {
835 pthread_cond_signal(&out->cond);
838 out->offload_thread_blocked = true;
839 pthread_mutex_unlock(&out->lock);
843 compress_wait(out->compr, -1);
848 compress_next_track(out->compr);
849 compress_partial_drain(out->compr);
854 compress_drain(out->compr);
862 pthread_mutex_lock(&out->lock);
863 out->offload_thread_blocked = false;
864 pthread_cond_signal(&out->cond);
866 out->offload_callback(event, NULL, out->offload_cookie);
871 pthread_cond_signal(&out->cond);
872 while (!list_empty(&out->offload_cmd_list)) {
873 item = list_head(&out->offload_cmd_list);
877 pthread_mutex_unlock(&out->lock);
882 static int create_offload_callback_thread(struct stream_out *out)
884 pthread_cond_init(&out->offload_cond, (const pthread_condattr_t *) NULL);
885 list_init(&out->offload_cmd_list);
886 pthread_create(&out->offload_thread, (const pthread_attr_t *) NULL,
887 offload_thread_loop, out);
891 static int destroy_offload_callback_thread(struct stream_out *out)
893 pthread_mutex_lock(&out->lock);
894 stop_compressed_output_l(out);
895 send_offload_cmd_l(out, OFFLOAD_CMD_EXIT);
897 pthread_mutex_unlock(&out->lock);
898 pthread_join(out->offload_thread, (void **) NULL);
899 pthread_cond_destroy(&out->offload_cond);
981 static int stop_output_stream(struct stream_out *out)
985 struct audio_device *adev = out->dev;
988 out->usecase, use_case_table[out->usecase]);
989 uc_info = get_usecase_from_list(adev, out->usecase);
992 __func__, out->usecase);
996 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
998 adev->visualizer_stop_output(out->handle, out->pcm_device_id);
1000 adev->offload_effects_stop_output(out->handle, out->pcm_device_id);
1015 if (out->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL)
1022 int start_output_stream(struct stream_out *out)
1026 struct audio_device *adev = out->dev;
1029 __func__, out->usecase, use_case_table[out->usecase], out->devices);
1030 out->pcm_device_id = platform_get_pcm_device_id(out->usecase, PCM_PLAYBACK);
1031 if (out->pcm_device_id < 0) {
1033 __func__, out->pcm_device_id, out->usecase);
1039 uc_info->id = out->usecase;
1041 uc_info->stream.out = out;
1042 uc_info->devices = out->devices;
1047 if (out->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL)
1048 check_and_set_hdmi_channels(adev, out->config.channels);
1052 select_devices(adev, out->usecase);
1057 __func__, adev->snd_card, out->pcm_device_id, out->config.format);
1058 if (out->usecase != USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1061 if (out->usecase == USECASE_AUDIO_PLAYBACK_AFE_PROXY) {
1068 out->pcm = pcm_open(adev->snd_card, out->pcm_device_id,
1069 flags, &out->config);
1070 if (out->pcm == NULL || !pcm_is_ready(out->pcm)) {
1071 ALOGE("%s: %s", __func__, pcm_get_error(out->pcm));
1072 if (out->pcm != NULL) {
1073 pcm_close(out->pcm);
1074 out->pcm = NULL;
1086 out->pcm = NULL;
1087 out->compr = compress_open(adev->snd_card, out->pcm_device_id,
1088 COMPRESS_IN, &out->compr_config);
1089 if (out->compr && !is_compress_ready(out->compr)) {
1090 ALOGE("%s: %s", __func__, compress_get_error(out->compr));
1091 compress_close(out->compr);
1092 out->compr = NULL;
1096 if (out->offload_callback)
1097 compress_nonblock(out->compr, out->non_blocking);
1100 adev->visualizer_start_output(out->handle, out->pcm_device_id);
1102 adev->offload_effects_start_output(out->handle, out->pcm_device_id);
1107 stop_output_stream(out);
1168 struct stream_out *out = (struct stream_out *)stream;
1170 return out->sample_rate;
1180 struct stream_out *out = (struct stream_out *)stream;
1182 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1183 return out->compr_config.fragment_size;
1185 return out->config.period_size *
1191 struct stream_out *out = (struct stream_out *)stream;
1193 return out->channel_mask;
1198 struct stream_out *out = (struct stream_out *)stream;
1200 return out->format;
1210 struct stream_out *out = (struct stream_out *)stream;
1211 struct audio_device *adev = out->dev;
1214 out->usecase, use_case_table[out->usecase]);
1216 pthread_mutex_lock(&out->lock);
1217 if (!out->standby) {
1219 out->standby = true;
1220 if (out->usecase != USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1221 if (out->pcm) {
1222 pcm_close(out->pcm);
1223 out->pcm = NULL;
1226 stop_compressed_output_l(out);
1227 out->gapless_mdata.encoder_delay = 0;
1228 out->gapless_mdata.encoder_padding = 0;
1229 if (out->compr != NULL) {
1230 compress_close(out->compr);
1231 out->compr = NULL;
1234 stop_output_stream(out);
1237 pthread_mutex_unlock(&out->lock);
1247 static int parse_compress_metadata(struct stream_out *out, struct str_parms *parms)
1253 if (!out || !parms) {
1271 out->gapless_mdata = tmp_mdata;
1272 out->send_new_metadata = 1;
1274 out->gapless_mdata.encoder_delay, out->gapless_mdata.encoder_padding);
1279 static bool output_drives_call(struct audio_device *adev, struct stream_out *out)
1281 return out == adev->primary_output || out == adev->voice_tx_output;
1286 struct stream_out *out = (struct stream_out *)stream;
1287 struct audio_device *adev = out->dev;
1297 __func__, out->usecase, use_case_table[out->usecase], kvpairs);
1302 pthread_mutex_lock(&out->lock);
1312 if (out->devices == AUDIO_DEVICE_OUT_AUX_DIGITAL &&
1336 out->devices = val;
1338 if (!out->standby)
1339 select_devices(adev, out->usecase);
1341 if (output_drives_call(adev, out)) {
1344 adev->current_call_output = out;
1348 adev->current_call_output = out;
1355 pthread_mutex_unlock(&out->lock);
1361 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1362 parse_compress_metadata(out, parms);
1372 struct stream_out *out = (struct stream_out *)stream;
1385 while (out->supported_channel_masks[i] != 0) {
1387 if (out_channels_name_to_enum_table[j].value == out->supported_channel_masks[i]) {
1411 struct stream_out *out = (struct stream_out *)stream;
1413 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD)
1416 return (out->config.period_count * out->config.period_size * 1000) /
1417 (out->config.rate);
1423 struct stream_out *out = (struct stream_out *)stream;
1426 if (out->usecase == USECASE_AUDIO_PLAYBACK_MULTI_CH) {
1428 out->muted = (left == 0.0f);
1430 } else if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1432 struct audio_device *adev = out->dev;
1437 int pcm_device_id = platform_get_pcm_device_id(out->usecase,
1460 struct stream_out *out = (struct stream_out *)stream;
1461 struct audio_device *adev = out->dev;
1464 pthread_mutex_lock(&out->lock);
1465 if (out->standby) {
1466 out->standby = false;
1468 ret = start_output_stream(out);
1472 out->standby = true;
1477 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1479 if (out->send_new_metadata) {
1481 compress_set_gapless_metadata(out->compr, &out->gapless_mdata);
1482 out->send_new_metadata = 0;
1485 ret = compress_write(out->compr, buffer, bytes);
1488 send_offload_cmd_l(out, OFFLOAD_CMD_WAIT_FOR_BUFFER);
1490 if (!out->playback_started) {
1491 compress_start(out->compr);
1492 out->playback_started = 1;
1493 out->offload_state = OFFLOAD_STATE_PLAYING;
1495 pthread_mutex_unlock(&out->lock);
1498 if (out->pcm) {
1499 if (out->muted)
1502 if (out->usecase == USECASE_AUDIO_PLAYBACK_AFE_PROXY) {
1503 ret = pcm_mmap_write(out->pcm, (void *)buffer, bytes);
1506 ret = pcm_write(out->pcm, (void *)buffer, bytes);
1508 out->written += bytes / (out->config.channels * sizeof(short));
1513 pthread_mutex_unlock(&out->lock);
1516 if (out->pcm)
1517 ALOGE("%s: error %d - %s", __func__, ret, pcm_get_error(out->pcm));
1518 out_standby(&out->stream.common);
1520 out_get_sample_rate(&out->stream.common));
1528 struct stream_out *out = (struct stream_out *)stream;
1530 if ((out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) && (dsp_frames != NULL)) {
1531 pthread_mutex_lock(&out->lock);
1532 if (out->compr != NULL) {
1533 compress_get_tstamp(out->compr, (unsigned long *)dsp_frames,
1534 &out->sample_rate);
1536 __func__, *dsp_frames, out->sample_rate);
1538 pthread_mutex_unlock(&out->lock);
1565 struct stream_out *out = (struct stream_out *)stream;
1569 pthread_mutex_lock(&out->lock);
1571 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1572 if (out->compr != NULL) {
1573 compress_get_tstamp(out->compr, &dsp_frames,
1574 &out->sample_rate);
1576 __func__, dsp_frames, out->sample_rate);
1583 if (out->pcm) {
1585 if (pcm_get_htimestamp(out->pcm, &avail, timestamp) == 0) {
1586 size_t kernel_buffer_size = out->config.period_size * out->config.period_count;
1587 int64_t signed_frames = out->written - kernel_buffer_size + avail;
1591 (platform_render_latency(out->usecase) * out->sample_rate / 1000000LL);
1602 pthread_mutex_unlock(&out->lock);
1610 struct stream_out *out = (struct stream_out *)stream;
1613 pthread_mutex_lock(&out->lock);
1614 out->offload_callback = callback;
1615 out->offload_cookie = cookie;
1616 pthread_mutex_unlock(&out->lock);
1622 struct stream_out *out = (struct stream_out *)stream;
1625 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1626 pthread_mutex_lock(&out->lock);
1627 if (out->compr != NULL && out->offload_state == OFFLOAD_STATE_PLAYING) {
1628 status = compress_pause(out->compr);
1629 out->offload_state = OFFLOAD_STATE_PAUSED;
1631 pthread_mutex_unlock(&out->lock);
1638 struct stream_out *out = (struct stream_out *)stream;
1641 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1643 pthread_mutex_lock(&out->lock);
1644 if (out->compr != NULL && out->offload_state == OFFLOAD_STATE_PAUSED) {
1645 status = compress_resume(out->compr);
1646 out->offload_state = OFFLOAD_STATE_PLAYING;
1648 pthread_mutex_unlock(&out->lock);
1655 struct stream_out *out = (struct stream_out *)stream;
1658 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1659 pthread_mutex_lock(&out->lock);
1661 status = send_offload_cmd_l(out, OFFLOAD_CMD_PARTIAL_DRAIN);
1663 status = send_offload_cmd_l(out, OFFLOAD_CMD_DRAIN);
1664 pthread_mutex_unlock(&out->lock);
1671 struct stream_out *out = (struct stream_out *)stream;
1673 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1674 pthread_mutex_lock(&out->lock);
1675 stop_compressed_output_l(out);
1676 pthread_mutex_unlock(&out->lock);
1924 struct stream_out *out;
1930 out = (struct stream_out *)calloc(1, sizeof(struct stream_out));
1935 out->flags = flags;
1936 out->devices = devices;
1937 out->dev = adev;
1938 out->format = config->format;
1939 out->sample_rate = config->sample_rate;
1940 out->channel_mask = AUDIO_CHANNEL_OUT_STEREO;
1941 out
1942 out->handle = handle;
1945 if (out->flags & AUDIO_OUTPUT_FLAG_DIRECT &&
1946 !(out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) &&
1947 out->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL) {
1949 ret = read_hdmi_channel_masks(out);
1959 out->channel_mask = config->channel_mask;
1960 out->sample_rate = config->sample_rate;
1961 out->usecase = USECASE_AUDIO_PLAYBACK_MULTI_CH;
1962 out->config = pcm_config_hdmi_multi;
1963 out->config.rate = config->sample_rate;
1964 out->config.channels = audio_channel_count_from_out_mask(out->channel_mask);
1965 out->config.period_size = HDMI_MULTI_PERIOD_BYTES / (out->config.channels * 2);
1966 } else if (out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) {
1979 out->compr_config.codec = (struct snd_codec *)
1982 out->usecase = USECASE_AUDIO_PLAYBACK_OFFLOAD;
1984 out->channel_mask = config->offload_info.channel_mask;
1986 out->channel_mask = config->channel_mask;
1987 out->format = config->offload_info.format;
1988 out->sample_rate = config->offload_info.sample_rate;
1990 out->stream.set_callback = out_set_callback;
1991 out->stream.pause = out_pause;
1992 out->stream.resume = out_resume;
1993 out->stream.drain = out_drain;
1994 out->stream.flush = out_flush;
1996 out->compr_config.codec->id =
1998 out->compr_config.fragment_size = COMPRESS_OFFLOAD_FRAGMENT_SIZE;
1999 out->compr_config.fragments = COMPRESS_OFFLOAD_NUM_FRAGMENTS;
2000 out->compr_config.codec->sample_rate =
2002 out->compr_config.codec->bit_rate =
2004 out->compr_config.codec->ch_in =
2006 out->compr_config.codec->ch_out = out->compr_config.codec->ch_in;
2009 out->non_blocking = 1;
2011 out->send_new_metadata = 1;
2012 create_offload_callback_thread(out);
2016 } else if (out->devices == AUDIO_DEVICE_OUT_TELEPHONY_TX) {
2025 out->sample_rate = config->sample_rate;
2026 out->config.rate = config->sample_rate;
2034 out->format = config->format;
2035 out->usecase = USECASE_AUDIO_PLAYBACK_AFE_PROXY;
2036 out->config = pcm_config_afe_proxy_playback;
2037 adev->voice_tx_output = out;
2039 if (out->flags & AUDIO_OUTPUT_FLAG_DEEP_BUFFER) {
2040 out->usecase = USECASE_AUDIO_PLAYBACK_DEEP_BUFFER;
2041 out->config = pcm_config_deep_buffer;
2043 out->usecase = USECASE_AUDIO_PLAYBACK_LOW_LATENCY;
2044 out->config = pcm_config_low_latency;
2046 if (config->format != audio_format_from_pcm_format(out->config.format)) {
2048 && pcm_params_format_test(adev->use_case_table[out->usecase],
2050 out->config.format = pcm_format_from_audio_format(config->format);
2051 /* out->format already set to config->format */
2055 * Note: out->format is returned by out->stream.common.get_format()
2058 out->format = audio_format_from_pcm_format(out->config.format);
2061 out->sample_rate = out->config.rate;
2063 ALOGV("%s: Usecase(%s) config->format %#x out->config.format %#x\n",
2064 __func__, use_case_table[out->usecase], config->format, out->config.format);
2068 adev->primary_output = out;
2078 if (get_usecase_from_list(adev, out->usecase) != NULL) {
2079 ALOGE("%s: Usecase (%d) is already present", __func__, out->usecase);
2086 out->stream.common.get_sample_rate = out_get_sample_rate;
2087 out->stream.common.set_sample_rate = out_set_sample_rate;
2088 out->stream.common.get_buffer_size = out_get_buffer_size;
2089 out->stream.common.get_channels = out_get_channels;
2090 out->stream.common.get_format = out_get_format;
2091 out->stream.common.set_format = out_set_format;
2092 out->stream.common.standby = out_standby;
2093 out->stream.common.dump = out_dump;
2094 out->stream.common.set_parameters = out_set_parameters;
2095 out->stream.common.get_parameters = out_get_parameters;
2096 out->stream.common.add_audio_effect = out_add_audio_effect;
2097 out->stream.common.remove_audio_effect = out_remove_audio_effect;
2098 out->stream.get_latency = out_get_latency;
2099 out->stream.set_volume = out_set_volume;
2100 out->stream.write = out_write;
2101 out->stream.get_render_position = out_get_render_position;
2102 out->stream.get_next_write_timestamp = out_get_next_write_timestamp;
2103 out->stream.get_presentation_position = out_get_presentation_position;
2105 out->standby = 1;
2106 /* out->muted = false; by calloc() */
2107 /* out->written = 0; by calloc() */
2109 pthread_mutex_init(&out->lock, (const pthread_mutexattr_t *) NULL);
2110 pthread_cond_init(&out->cond, (const pthread_condattr_t *) NULL);
2112 config->format = out->stream.common.get_format(&out->stream.common);
2113 config->channel_mask = out->stream.common.get_channels(&out->stream.common);
2114 config->sample_rate = out->stream.common.get_sample_rate(&out->stream.common);
2116 *stream_out = &out->stream;
2121 free(out);
2130 struct stream_out *out = (struct stream_out *)stream;
2131 struct audio_device *adev = out->dev;
2135 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2136 destroy_offload_callback_thread(out);
2138 if (out->compr_config.codec != NULL)
2139 free(out->compr_config.codec);
2142 if (adev->voice_tx_output == out)
2145 pthread_cond_destroy(&out->cond);
2146 pthread_mutex_destroy(&out->lock);
2532 struct stream_out out;
2559 memset(&out, 0, sizeof(out));
2560 out.devices = audio_device; /* only field needed in select_devices */
2561 uc_info.stream.out = &out;
2567 /* select device - similar to start_(in/out)put_stream() */
2583 /* deselect device - similar to stop_(in/out)put_stream() */
