/* Called from IO context */
static int unsuspend(struct userdata *u) {
int m;
pa_sample_spec ss, *ss_original;
int frag_size, in_frag_size, out_frag_size;
int in_nfrags, out_nfrags;
struct audio_buf_info info;
pa_assert(u);
pa_assert(u->fd < 0);
m = u->mode;
pa_log_info("Trying resume...");
if ((u->fd = pa_oss_open(u->device_name, &m, NULL)) < 0) {
pa_log_warn("Resume failed, device busy (%s)", pa_cstrerror(errno));
return -1;
}
if (m != u->mode) {
pa_log_warn("Resume failed, couldn't open device with original access mode.");
goto fail;
}
if (u->nfrags >= 2 && u->frag_size >= 1)
if (pa_oss_set_fragments(u->fd, u->nfrags, u->orig_frag_size) < 0) {
pa_log_warn("Resume failed, couldn't set original fragment settings.");
goto fail;
}
ss = *(ss_original = u->sink ? &u->sink->sample_spec : &u->source->sample_spec);
if (pa_oss_auto_format(u->fd, &ss) < 0 || !pa_sample_spec_equal(&ss, ss_original)) {
pa_log_warn("Resume failed, couldn't set original sample format settings.");
goto fail;
}
if (ioctl(u->fd, SNDCTL_DSP_GETBLKSIZE, &frag_size) < 0) {
pa_log_warn("SNDCTL_DSP_GETBLKSIZE: %s", pa_cstrerror(errno));
goto fail;
}
in_frag_size = out_frag_size = frag_size;
in_nfrags = out_nfrags = u->nfrags;
if (ioctl(u->fd, SNDCTL_DSP_GETISPACE, &info) >= 0) {
in_frag_size = info.fragsize;
in_nfrags = info.fragstotal;
}
if (ioctl(u->fd, SNDCTL_DSP_GETOSPACE, &info) >= 0) {
out_frag_size = info.fragsize;
out_nfrags = info.fragstotal;
}
if ((u->source && (in_frag_size != (int) u->in_fragment_size || in_nfrags != (int) u->in_nfrags)) ||
(u->sink && (out_frag_size != (int) u->out_fragment_size || out_nfrags != (int) u->out_nfrags))) {
pa_log_warn("Resume failed, input fragment settings don't match.");
goto fail;
}
if (u->use_mmap) {
if (u->source) {
if ((u->in_mmap = mmap(NULL, u->in_hwbuf_size, PROT_READ, MAP_SHARED, u->fd, 0)) == MAP_FAILED) {
pa_log("Resume failed, mmap(): %s", pa_cstrerror(errno));
goto fail;
}
}
if (u->sink) {
if ((u->out_mmap = mmap(NULL, u->out_hwbuf_size, PROT_WRITE, MAP_SHARED, u->fd, 0)) == MAP_FAILED) {
pa_log("Resume failed, mmap(): %s", pa_cstrerror(errno));
if (u->in_mmap && u->in_mmap != MAP_FAILED) {
munmap(u->in_mmap, u->in_hwbuf_size);
u->in_mmap = NULL;
}
goto fail;
}
pa_silence_memory(u->out_mmap, u->out_hwbuf_size, &ss);
}
}
u->out_mmap_current = u->in_mmap_current = 0;
u->out_mmap_saved_nfrags = u->in_mmap_saved_nfrags = 0;
pa_assert(!u->rtpoll_item);
build_pollfd(u);
if (u->sink && u->sink->get_volume)
u->sink->get_volume(u->sink);
if (u->source && u->source->get_volume)
u->source->get_volume(u->source);
pa_log_info("Resumed successfully...");
return 0;
fail:
pa_close(u->fd);
u->fd = -1;
return -1;
}
void PulseAudioSystem::write_callback(pa_stream *s, size_t bytes, void *userdata) {
PulseAudioSystem *pas = reinterpret_cast<PulseAudioSystem *>(userdata);
Q_ASSERT(s == pas->pasOutput);
AudioOutputPtr ao = g.ao;
PulseAudioOutput *pao = dynamic_cast<PulseAudioOutput *>(ao.get());
unsigned char buffer[bytes];
if (! pao) {
// Transitioning, but most likely transitions back, so just zero.
memset(buffer, 0, bytes);
pa_stream_write(s, buffer, bytes, NULL, 0, PA_SEEK_RELATIVE);
pas->wakeup();
return;
}
const pa_sample_spec *pss = pa_stream_get_sample_spec(s);
const pa_channel_map *pcm = pa_stream_get_channel_map(pas->pasOutput);
if (!pa_sample_spec_equal(pss, &pao->pss) || !pa_channel_map_equal(pcm, &pao->pcm)) {
pao->pss = *pss;
pao->pcm = *pcm;
if (pss->format == PA_SAMPLE_FLOAT32NE)
pao->eSampleFormat = PulseAudioOutput::SampleFloat;
else
pao->eSampleFormat = PulseAudioOutput::SampleShort;
pao->iMixerFreq = pss->rate;
pao->iChannels = pss->channels;
unsigned int chanmasks[pss->channels];
for (int i=0;i<pss->channels;++i) {
unsigned int cm = 0;
switch (pcm->map[i]) {
case PA_CHANNEL_POSITION_LEFT:
cm = SPEAKER_FRONT_LEFT;
break;
case PA_CHANNEL_POSITION_RIGHT:
cm = SPEAKER_FRONT_RIGHT;
break;
case PA_CHANNEL_POSITION_CENTER:
cm = SPEAKER_FRONT_CENTER;
break;
case PA_CHANNEL_POSITION_REAR_LEFT:
cm = SPEAKER_BACK_LEFT;
break;
case PA_CHANNEL_POSITION_REAR_RIGHT:
cm = SPEAKER_BACK_RIGHT;
break;
case PA_CHANNEL_POSITION_REAR_CENTER:
cm = SPEAKER_BACK_CENTER;
break;
case PA_CHANNEL_POSITION_LFE:
cm = SPEAKER_LOW_FREQUENCY;
break;
case PA_CHANNEL_POSITION_SIDE_LEFT:
cm = SPEAKER_SIDE_LEFT;
break;
case PA_CHANNEL_POSITION_SIDE_RIGHT:
cm = SPEAKER_SIDE_RIGHT;
break;
case PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER:
cm = SPEAKER_FRONT_LEFT_OF_CENTER;
break;
case PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER:
cm = SPEAKER_FRONT_RIGHT_OF_CENTER;
break;
default:
cm = 0;
break;
}
chanmasks[i] = cm;
}
pao->initializeMixer(chanmasks);
}
const unsigned int iSampleSize = pao->iSampleSize;
const unsigned int samples = static_cast<unsigned int>(bytes) / iSampleSize;
bool oldAttenuation = pas->bAttenuating;
// do we have some mixed output?
if (pao->mix(buffer, samples)) {
// attenuate if instructed to or it's in settings
pas->bAttenuating = (g.bAttenuateOthers || g.s.bAttenuateOthers);
} else {
memset(buffer, 0, bytes);
// attenuate if intructed to (self-activated)
pas->bAttenuating = g.bAttenuateOthers;
}
// if the attenuation state has changed
if (oldAttenuation != pas->bAttenuating) {
pas->setVolumes();
}
pa_stream_write(s, buffer, iSampleSize * samples, NULL, 0, PA_SEEK_RELATIVE);
}
/* Called from main context */
int pa_source_output_finish_move(pa_source_output *o, pa_source *dest, pa_bool_t save) {
pa_resampler *new_resampler;
pa_source_output_assert_ref(o);
pa_assert_ctl_context();
pa_assert(PA_SOURCE_OUTPUT_IS_LINKED(o->state));
pa_assert(!o->source);
pa_source_assert_ref(dest);
if (!pa_source_output_may_move_to(o, dest))
return -1;
if (o->thread_info.resampler &&
pa_sample_spec_equal(pa_resampler_input_sample_spec(o->thread_info.resampler), &dest->sample_spec) &&
pa_channel_map_equal(pa_resampler_input_channel_map(o->thread_info.resampler), &dest->channel_map))
/* Try to reuse the old resampler if possible */
new_resampler = o->thread_info.resampler;
else if ((o->flags & PA_SOURCE_OUTPUT_VARIABLE_RATE) ||
!pa_sample_spec_equal(&o->sample_spec, &dest->sample_spec) ||
!pa_channel_map_equal(&o->channel_map, &dest->channel_map)) {
/* Okey, we need a new resampler for the new source */
if (!(new_resampler = pa_resampler_new(
o->core->mempool,
&dest->sample_spec, &dest->channel_map,
&o->sample_spec, &o->channel_map,
o->requested_resample_method,
((o->flags & PA_SOURCE_OUTPUT_VARIABLE_RATE) ? PA_RESAMPLER_VARIABLE_RATE : 0) |
((o->flags & PA_SOURCE_OUTPUT_NO_REMAP) ? PA_RESAMPLER_NO_REMAP : 0) |
(o->core->disable_remixing || (o->flags & PA_SOURCE_OUTPUT_NO_REMIX) ? PA_RESAMPLER_NO_REMIX : 0)))) {
pa_log_warn("Unsupported resampling operation.");
return -PA_ERR_NOTSUPPORTED;
}
} else
new_resampler = NULL;
if (o->moving)
o->moving(o, dest);
o->source = dest;
o->save_source = save;
pa_idxset_put(o->source->outputs, pa_source_output_ref(o), NULL);
if (pa_source_output_get_state(o) == PA_SOURCE_OUTPUT_CORKED)
o->source->n_corked++;
/* Replace resampler */
if (new_resampler != o->thread_info.resampler) {
if (o->thread_info.resampler)
pa_resampler_free(o->thread_info.resampler);
o->thread_info.resampler = new_resampler;
pa_memblockq_free(o->thread_info.delay_memblockq);
o->thread_info.delay_memblockq = pa_memblockq_new(
0,
MEMBLOCKQ_MAXLENGTH,
0,
pa_frame_size(&o->source->sample_spec),
0,
1,
0,
&o->source->silence);
o->actual_resample_method = new_resampler ? pa_resampler_get_method(new_resampler) : PA_RESAMPLER_INVALID;
}
pa_source_update_status(dest);
pa_assert_se(pa_asyncmsgq_send(o->source->asyncmsgq, PA_MSGOBJECT(o->source), PA_SOURCE_MESSAGE_ADD_OUTPUT, o, 0, NULL) == 0);
pa_log_debug("Successfully moved source output %i to %s.", o->index, dest->name);
/* Notify everyone */
pa_hook_fire(&o->core->hooks[PA_CORE_HOOK_SOURCE_OUTPUT_MOVE_FINISH], o);
pa_subscription_post(o->core, PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT|PA_SUBSCRIPTION_EVENT_CHANGE, o->index);
return 0;
}
void PulseAudioSystem::read_callback(pa_stream *s, size_t bytes, void *userdata) {
PulseAudioSystem *pas = reinterpret_cast<PulseAudioSystem *>(userdata);
size_t length = bytes;
const void *data = NULL;
pa_stream_peek(s, &data, &length);
if (data == NULL && length > 0) {
qWarning("PulseAudio: pa_stream_peek reports no data at current read index.");
} else if (data == NULL && length == 0) {
qWarning("PulseAudio: pa_stream_peek reports empty memblockq.");
} else if (data == NULL || length == 0) {
qWarning("PulseAudio: invalid pa_stream_peek state encountered.");
return;
}
AudioInputPtr ai = g.ai;
PulseAudioInput *pai = dynamic_cast<PulseAudioInput *>(ai.get());
if (! pai) {
if (length > 0) {
pa_stream_drop(s);
}
pas->wakeup();
return;
}
const pa_sample_spec *pss = pa_stream_get_sample_spec(s);
if (s == pas->pasInput) {
if (!pa_sample_spec_equal(pss, &pai->pssMic)) {
pai->pssMic = *pss;
pai->iMicFreq = pss->rate;
pai->iMicChannels = pss->channels;
if (pss->format == PA_SAMPLE_FLOAT32NE)
pai->eMicFormat = PulseAudioInput::SampleFloat;
else
pai->eMicFormat = PulseAudioInput::SampleShort;
pai->initializeMixer();
}
if (data != NULL) {
pai->addMic(data, static_cast<unsigned int>(length) / pai->iMicSampleSize);
}
} else if (s == pas->pasSpeaker) {
if (!pa_sample_spec_equal(pss, &pai->pssEcho)) {
pai->pssEcho = *pss;
pai->iEchoFreq = pss->rate;
pai->iEchoChannels = pss->channels;
if (pss->format == PA_SAMPLE_FLOAT32NE)
pai->eEchoFormat = PulseAudioInput::SampleFloat;
else
pai->eEchoFormat = PulseAudioInput::SampleShort;
pai->initializeMixer();
}
if (data != NULL) {
pai->addEcho(data, static_cast<unsigned int>(length) / pai->iEchoSampleSize);
}
}
if (length > 0) {
pa_stream_drop(s);
}
}
/* Called from main context */
int pa_source_output_new(
pa_source_output**_o,
pa_core *core,
pa_source_output_new_data *data) {
pa_source_output *o;
pa_resampler *resampler = NULL;
char st[PA_SAMPLE_SPEC_SNPRINT_MAX], cm[PA_CHANNEL_MAP_SNPRINT_MAX];
int r;
char *pt;
pa_assert(_o);
pa_assert(core);
pa_assert(data);
pa_assert_ctl_context();
if (data->client)
pa_proplist_update(data->proplist, PA_UPDATE_MERGE, data->client->proplist);
if ((r = pa_hook_fire(&core->hooks[PA_CORE_HOOK_SOURCE_OUTPUT_NEW], data)) < 0)
return r;
pa_return_val_if_fail(!data->driver || pa_utf8_valid(data->driver), -PA_ERR_INVALID);
if (!data->source) {
data->source = pa_namereg_get(core, NULL, PA_NAMEREG_SOURCE);
data->save_source = FALSE;
}
pa_return_val_if_fail(data->source, -PA_ERR_NOENTITY);
pa_return_val_if_fail(PA_SOURCE_IS_LINKED(pa_source_get_state(data->source)), -PA_ERR_BADSTATE);
pa_return_val_if_fail(!data->direct_on_input || data->direct_on_input->sink == data->source->monitor_of, -PA_ERR_INVALID);
if (!data->sample_spec_is_set)
data->sample_spec = data->source->sample_spec;
pa_return_val_if_fail(pa_sample_spec_valid(&data->sample_spec), -PA_ERR_INVALID);
if (!data->channel_map_is_set) {
if (pa_channel_map_compatible(&data->source->channel_map, &data->sample_spec))
data->channel_map = data->source->channel_map;
else
pa_channel_map_init_extend(&data->channel_map, data->sample_spec.channels, PA_CHANNEL_MAP_DEFAULT);
}
pa_return_val_if_fail(pa_channel_map_valid(&data->channel_map), -PA_ERR_INVALID);
pa_return_val_if_fail(pa_channel_map_compatible(&data->channel_map, &data->sample_spec), -PA_ERR_INVALID);
if (data->flags & PA_SOURCE_OUTPUT_FIX_FORMAT)
data->sample_spec.format = data->source->sample_spec.format;
if (data->flags & PA_SOURCE_OUTPUT_FIX_RATE)
data->sample_spec.rate = data->source->sample_spec.rate;
if (data->flags & PA_SOURCE_OUTPUT_FIX_CHANNELS) {
data->sample_spec.channels = data->source->sample_spec.channels;
data->channel_map = data->source->channel_map;
}
pa_assert(pa_sample_spec_valid(&data->sample_spec));
pa_assert(pa_channel_map_valid(&data->channel_map));
if (data->resample_method == PA_RESAMPLER_INVALID)
data->resample_method = core->resample_method;
pa_return_val_if_fail(data->resample_method < PA_RESAMPLER_MAX, -PA_ERR_INVALID);
if ((r = pa_hook_fire(&core->hooks[PA_CORE_HOOK_SOURCE_OUTPUT_FIXATE], data)) < 0)
return r;
if ((data->flags & PA_SOURCE_OUTPUT_NO_CREATE_ON_SUSPEND) &&
pa_source_get_state(data->source) == PA_SOURCE_SUSPENDED) {
pa_log("Failed to create source output: source is suspended.");
return -PA_ERR_BADSTATE;
}
if (pa_idxset_size(data->source->outputs) >= PA_MAX_OUTPUTS_PER_SOURCE) {
pa_log("Failed to create source output: too many outputs per source.");
return -PA_ERR_TOOLARGE;
}
if ((data->flags & PA_SOURCE_OUTPUT_VARIABLE_RATE) ||
!pa_sample_spec_equal(&data->sample_spec, &data->source->sample_spec) ||
!pa_channel_map_equal(&data->channel_map, &data->source->channel_map)) {
if (!(resampler = pa_resampler_new(
core->mempool,
&data->source->sample_spec, &data->source->channel_map,
&data->sample_spec, &data->channel_map,
data->resample_method,
((data->flags & PA_SOURCE_OUTPUT_VARIABLE_RATE) ? PA_RESAMPLER_VARIABLE_RATE : 0) |
((data->flags & PA_SOURCE_OUTPUT_NO_REMAP) ? PA_RESAMPLER_NO_REMAP : 0) |
(core->disable_remixing || (data->flags & PA_SOURCE_OUTPUT_NO_REMIX) ? PA_RESAMPLER_NO_REMIX : 0) |
(core->disable_lfe_remixing ? PA_RESAMPLER_NO_LFE : 0)))) {
pa_log_warn("Unsupported resampling operation.");
return -PA_ERR_NOTSUPPORTED;
}
}
o = pa_msgobject_new(pa_source_output);
o->parent.parent.free = source_output_free;
o->parent.process_msg = pa_source_output_process_msg;
o->core = core;
o->state = PA_SOURCE_OUTPUT_INIT;
o->flags = data->flags;
o->proplist = pa_proplist_copy(data->proplist);
o->driver = pa_xstrdup(pa_path_get_filename(data->driver));
o->module = data->module;
o->source = data->source;
o->destination_source = data->destination_source;
o->client = data->client;
o->actual_resample_method = resampler ? pa_resampler_get_method(resampler) : PA_RESAMPLER_INVALID;
o->requested_resample_method = data->resample_method;
o->sample_spec = data->sample_spec;
o->channel_map = data->channel_map;
o->direct_on_input = data->direct_on_input;
o->save_source = data->save_source;
reset_callbacks(o);
o->userdata = NULL;
o->thread_info.state = o->state;
o->thread_info.attached = FALSE;
o->thread_info.sample_spec = o->sample_spec;
o->thread_info.resampler = resampler;
o->thread_info.requested_source_latency = (pa_usec_t) -1;
o->thread_info.direct_on_input = o->direct_on_input;
o->thread_info.delay_memblockq = pa_memblockq_new(
0,
MEMBLOCKQ_MAXLENGTH,
0,
pa_frame_size(&o->source->sample_spec),
0,
1,
0,
&o->source->silence);
pa_assert_se(pa_idxset_put(core->source_outputs, o, &o->index) == 0);
pa_assert_se(pa_idxset_put(o->source->outputs, pa_source_output_ref(o), NULL) == 0);
if (o->client)
pa_assert_se(pa_idxset_put(o->client->source_outputs, o, NULL) >= 0);
if (o->direct_on_input)
pa_assert_se(pa_idxset_put(o->direct_on_input->direct_outputs, o, NULL) == 0);
pt = pa_proplist_to_string_sep(o->proplist, "\n ");
pa_log_info("Created output %u \"%s\" on %s with sample spec %s and channel map %s\n %s",
o->index,
pa_strnull(pa_proplist_gets(o->proplist, PA_PROP_MEDIA_NAME)),
o->source->name,
pa_sample_spec_snprint(st, sizeof(st), &o->sample_spec),
pa_channel_map_snprint(cm, sizeof(cm), &o->channel_map),
pt);
pa_xfree(pt);
/* Don't forget to call pa_source_output_put! */
*_o = o;
return 0;
}
