void
ClientNode::_DataAvailable(bigtime_t time)
{
size_t samples = fFormat.u.raw_audio.buffer_size / sizeof(float);
fFramesSent += samples;
JackPortList* ports = fOwner->GetOutputPorts();
for (int i = 0; i < ports->CountItems(); i++) {
JackPort* port = ports->ItemAt(i);
if (port != NULL && port->IsConnected()) {
BBuffer* buffer = FillNextBuffer(time, port);
if (buffer) {
if (SendBuffer(buffer,
port->MediaOutput()->source, port->MediaOutput()->destination)
!= B_OK) {
printf("ClientNode::_DataAvailable: Buffer sending "
"failed\n");
buffer->Recycle();
}
size_t nFrames = fFormat.u.raw_audio.buffer_size
/ ((fFormat.u.raw_audio.format
& media_raw_audio_format::B_AUDIO_SIZE_MASK)
* fFormat.u.raw_audio.channel_count);
}
if (buffer == NULL)
return;
}
}
}
void
ClientNode::Connect(status_t status,
const media_source &src, const media_destination &dst,
const media_format &format, char* name)
{
if (status != B_OK)
return;
media_node_id id;
FindLatencyFor(dst, &fDownstreamLatency, &id);
fOwner->SetFormat(format);
JackPort* port;
JackPortList* outputs = fOwner->GetOutputPorts();
for (int i = 0; i < outputs->CountItems(); i++) {
port = outputs->ItemAt(i);
BString str(jack_port_name((jack_port_t*) port));
if (str.Compare(name) == 0 && !port->IsConnected()) {
printf("ClientNode::Connect %s\n", port->Name());
port->MediaOutput()->source = src;
port->MediaOutput()->destination = dst;
port->MediaOutput()->format = format;
break;
}
}
}
JackPort*
ClientNode::_FindOutputPort(media_source source, media_destination dest) const
{
JackPort* port;
JackPortList* outputs = fOwner->GetOutputPorts();
for (int i = 0; i < outputs->CountItems(); i++) {
port = outputs->ItemAt(i);
if (source == port->MediaOutput()->source && dest ==
port->MediaOutput()->destination)
return port;
}
}
void
ClientNode::ProducerDataStatus(const media_destination &dst, int32 status,
bigtime_t when)
{
printf("ClientNode::ProducerDataStatus(\n");
JackPortList* ports = fOwner->GetOutputPorts();
for (int i = 0; i < ports->CountItems(); i++) {
JackPort* port = ports->ItemAt(i);
if (port->MediaOutput()->destination != media_destination::null)
SendDataStatus(status, port->MediaOutput()->destination, when);
}
}
void
ClientNode::Disconnect(const media_source &src,
const media_destination &dst)
{
printf("ClientNode::Disconnect\n");
JackPort* port;
JackPortList* outputs = fOwner->GetOutputPorts();
for (int i = 0; i < outputs->CountItems(); i++) {
port = outputs->ItemAt(i);
if (port->MediaOutput()->source == src
&& port->MediaOutput()->destination == dst) {
port->SetConnected(false);
}
}
}
int
JackClient::ConnectPorts(const char* source, const char* destination)
{
media_node sourceNode = FindNativeNode(source);
media_node destNode = FindNativeNode(destination);
JackPort* port = PortByName(source);
if (port == NULL)
printf("port is NULL\n");
printf("%s\n", port->Name());
media_source src(sourceNode.port, 0);
media_format format;
format.type = B_MEDIA_RAW_AUDIO;
format.u.raw_audio.buffer_size = fFormat.u.raw_audio.buffer_size;
format.u.raw_audio = media_raw_audio_format::wildcard;
format.u.raw_audio.channel_count = 1;
format.u.raw_audio.format = WRAPPER_PREFERRED_FORMAT;
media_destination dest(destNode.port, 0);
media_output* output = port->MediaOutput();
output->node = sourceNode;
output->source = src;
output->destination = dest;
output->format = format;
strcpy(output->name, source);
media_input* input = port->MediaInput();
input->node = destNode;
input->source = src;
input->destination = dest;
input->format = format;
strcpy(input->name, destination);
if (status_t ret = fRoster->Connect(src, dest, &format, output, input)
!= B_OK) {
printf("error connecting %s\n", strerror(ret));
return -1;
}
port->SetConnected(true);
return 0;
}
status_t
ClientNode::PrepareToConnect(const media_source &src,
const media_destination &dst,
media_format *format, media_source *out_source,
char *name)
{
printf("ClientNode::PrepareToConnect\n");
if (dst.port == ControlPort())
return B_MEDIA_BAD_SOURCE;
if (src.port != ControlPort() || src.id != 0)
return B_MEDIA_BAD_SOURCE;
if (format->type != B_MEDIA_RAW_AUDIO
&& format->type != B_MEDIA_UNKNOWN_TYPE) {
return B_MEDIA_BAD_FORMAT;
}
JackPort* port;
JackPortList* outputs = fOwner->GetOutputPorts();
for (int i = 0; i < outputs->CountItems(); i++) {
port = outputs->ItemAt(i);
media_output* output = port->MediaOutput();
if (output->source.id == src.id
&& output->destination.id == dst.id) {
if (port->IsConnected())
return B_MEDIA_ALREADY_CONNECTED;
*out_source = src;
BString portName(jack_port_name((jack_port_t*) port));
portName.CopyInto(name, 0, portName.Length());
printf("Connecting to %s\n", name);
format->SpecializeTo(&fFormat);
return B_OK;
}
}
return B_MEDIA_BAD_SOURCE;
}
status_t
ClientNode::GetNextOutput(int32 *cookie, media_output *output)
{
//printf("ClientNode::GetNextOutput %d\n", *cookie);
JackPortList* ports = fOwner->GetOutputPorts();
if (*cookie >= ports->CountItems())
return B_BAD_INDEX;
JackPort* port = ports->ItemAt(*cookie);
if (port == NULL)
return B_BAD_INDEX;
*output = *port->MediaOutput();
*cookie += 1;
return B_OK;
}
jack_port_t*
JackClient::RegisterPort(const char *port_name,
const char *port_type, unsigned long flags,
unsigned long buffer_size)
{
unsigned long size;
if (buffer_size == 0) {
if (strcmp(port_type, JACK_DEFAULT_AUDIO_TYPE) == 0) {
size = fFormat.u.raw_audio.buffer_size;
} else if (strcmp(port_type, JACK_DEFAULT_MIDI_TYPE) == 0) {
// not supported atm
return NULL;
}
} else
size = buffer_size;
JackPort* port = new JackPort(port_name, port_type,
flags, size, this);
if (flags & JackPortIsInput)
fInputPorts->AddItem(port);
else if (flags & JackPortIsOutput)
fOutputPorts->AddItem(port);
media_output* output = port->MediaOutput();
output->node = fClientNode->Node();
output->source.port = fClientNode->ControlPort();
output->source.id = 0;
output->destination = media_destination::null;
output->format = fFormat;
strcpy(output->name, jack_port_name((jack_port_t*)port));
return (jack_port_t*) port;
}
