void
BMediaEventLooper::SetEventLatency(bigtime_t latency)
{
CALLED();
// clamp to a valid value
if (latency < 0)
latency = 0;
fEventLatency = latency;
write_port_etc(ControlPort(), GENERAL_PURPOSE_WAKEUP, 0, 0, B_TIMEOUT, 0);
}
SystemTimeSource::~SystemTimeSource()
{
TRACE("SystemTimeSource::~SystemTimeSource enter\n");
close_port(ControlPort());
if (fControlThread != -1) {
status_t err;
wait_for_thread(fControlThread, &err);
}
TRACE("SystemTimeSource::~SystemTimeSource exit\n");
}
// BMediaEventLooper methods
void EMBeOutputNode::NodeRegistered()
{
// set up as much information about our output as we can
m_sOutput.source.port = ControlPort();
m_sOutput.source.id = 0;
memcpy(&(m_sOutput.node), &(Node()), sizeof(media_node));
::strcpy(m_sOutput.name, "Titan Alpha 0.1");
// Start the BMediaEventLooper thread
SetPriority(B_REAL_TIME_PRIORITY);
Run();
}
status_t
ClientNode::SetBufferGroup(const media_source &src,
BBufferGroup *group)
{
printf("ClientNode::SetBufferGroup\n");
if (src.port != ControlPort() || src.id != 0)
return B_MEDIA_BAD_SOURCE;
fBufferGroup = group;
return B_OK;
}
// BMediaEventLooper methods
void
GameProducer::NodeRegistered()
{
// set up as much information about our output as we can
fOutput.source.port = ControlPort();
fOutput.source.id = 0;
fOutput.node = Node();
strlcpy(fOutput.name, "GameProducer Output", B_MEDIA_NAME_LENGTH);
// Start the BMediaEventLooper thread
SetPriority(B_REAL_TIME_PRIORITY);
Run();
}
void VideoMixerNode::NodeRegistered(void)
{
fprintf(stderr,"VideoMixerNode::NodeRegistered\n");
// for every node created so far set to this Node;
for (uint32 i=0;i<fConnectedInputs.size();i++) {
fConnectedInputs[i]->node = Node();
fConnectedInputs[i]->destination.id = i;
fConnectedInputs[i]->destination.port = ControlPort();
}
fInitialInput.node = Node();
fInitialInput.destination.id = fConnectedInputs.size();
fInitialInput.destination.port = ControlPort();
GetOutputFormat(&fOutput.format);
fOutput.node = Node();
// start the BMediaEventLooper thread
SetPriority(B_REAL_TIME_PRIORITY);
Run();
}
status_t
AudioConsumer::GetLatencyFor(const media_destination& dst,
bigtime_t* latency, media_node_id* time_src)
{
// we have multiple inputs with different IDs, but
// the port number must match our ControlPort()
if (dst.port != ControlPort())
return B_MEDIA_BAD_DESTINATION;
*latency = EventLatency();
*time_src += TimeSource()->ID();
return B_OK;
}
status_t
AudioConsumer::Connected(const media_source& src,
const media_destination& dst, const media_format& format,
media_input* input)
{
if (src.id != 0 || src.port != ControlPort())
return B_MEDIA_BAD_DESTINATION;
fInput.source = src;
fInput.format = format;
*input = fInput;
return B_OK;
}
status_t
FireWireDVNode::PrepareToConnect(const media_source& source,
const media_destination& destination, media_format* format,
media_source* out_source, char* out_name)
{
/* The connection process:
* BBufferProducer::FormatProposal
* BBufferConsumer::AcceptFormat
* we are here => BBufferProducer::PrepareToConnect
* BBufferConsumer::Connected
* BBufferProducer::Connect
*
* At this point, the consumer's AcceptFormat() method has been called,
* and that node has potentially changed the proposed format. It may
* also have left wildcards in the format. PrepareToConnect()
* *must* fully specialize the format before returning!
*/
CALLED();
// is the source valid?
if (source.port != ControlPort() &&
fCard->DetectRecvFn() != B_OK) {
fprintf(stderr, "FireWireDVNode::PrepareToConnect returning "
"B_MEDIA_BAD_SOURCE\n");
return B_MEDIA_BAD_SOURCE;
}
// are we already connected?
if (fOutputEncVideo.destination != media_destination::null)
return B_MEDIA_ALREADY_CONNECTED;
// the format may not yet be fully specialized (the consumer might have
// passed back some wildcards). Finish specializing it now, and return an
// error if we don't support the requested format.
if (format->type != B_MEDIA_RAW_AUDIO) {
fprintf(stderr, "\tnon-raw-audio format?!\n");
return B_MEDIA_BAD_FORMAT;
}
// reserve the connection by setting destination
// set the output's format to the new format
fOutputEncVideo.destination = destination;
fOutputEncVideo.format = *format;
// set source and suggest a name
*out_source = source;
strcpy(out_name, "encoded video");
return B_OK;
}
void
VideoNode::NodeRegistered()
{
fInput.node = Node();
fInput.source = media_source::null;
fInput.destination.port = ControlPort();
fInput.destination.id = 0;
fInput.format.type = B_MEDIA_RAW_VIDEO;
fInput.format.u.raw_video = media_raw_video_format::wildcard;
strcpy(fInput.name, "video in");
SetPriority(B_DISPLAY_PRIORITY);
Run();
}
void StepMotionBlurFilter::NodeRegistered() {
PRINT(("StepMotionBlurFilter::NodeRegistered()\n"));
// Start the BMediaEventLooper thread
SetPriority(B_REAL_TIME_PRIORITY);
Run();
// figure preferred ('template') format
m_preferredFormat.type = B_MEDIA_RAW_VIDEO;
m_preferredFormat.u.raw_video = media_raw_video_format::wildcard;
// getPreferredFormat(m_preferredFormat);
// initialize current format
m_format.type = B_MEDIA_RAW_VIDEO;
m_format.u.raw_video = media_raw_video_format::wildcard;
// init input
m_input.destination.port = ControlPort();
m_input.destination.id = ID_VIDEO_INPUT;
m_input.node = Node();
m_input.source = media_source::null;
m_input.format = m_format;
strncpy(m_input.name, "Video Input", B_MEDIA_NAME_LENGTH);
// init output
m_output.source.port = ControlPort();
m_output.source.id = ID_VIDEO_MIX_OUTPUT;
m_output.node = Node();
m_output.destination = media_destination::null;
m_output.format = m_format;
strncpy(m_output.name, "Mix Output", B_MEDIA_NAME_LENGTH);
// init parameters
initParameterValues();
// initParameterWeb();
}
void AudioFilterNode::NodeRegistered() {
PRINT(("AudioFilterNode::NodeRegistered()\n"));
status_t err;
// Start the BMediaEventLooper thread
SetPriority(B_REAL_TIME_PRIORITY);
Run();
// init input
m_input.destination.port = ControlPort();
m_input.destination.id = ID_AUDIO_INPUT;
m_input.node = Node();
m_input.source = media_source::null;
m_input.format.type = B_MEDIA_RAW_AUDIO;
err = getRequiredInputFormat(m_input.format);
ASSERT(err == B_OK);
strncpy(m_input.name, "Audio Input", B_MEDIA_NAME_LENGTH);
// init output
m_output.source.port = ControlPort();
m_output.source.id = ID_AUDIO_MIX_OUTPUT;
m_output.node = Node();
m_output.destination = media_destination::null;
m_output.format.type = B_MEDIA_RAW_AUDIO;
err = getRequiredOutputFormat(m_output.format);
ASSERT(err == B_OK);
strncpy(m_output.name, "Audio Output", B_MEDIA_NAME_LENGTH);
// init parameters
initParameterWeb();
}
void
AudioProducer::NodeRegistered()
{
TRACE("%p->AudioProducer::NodeRegistered()\n", this);
// Start the BMediaEventLooper thread
SetPriority(B_REAL_TIME_PRIORITY);
Run();
// set up as much information about our output as we can
fOutput.source.port = ControlPort();
fOutput.source.id = 0;
fOutput.node = Node();
::strcpy(fOutput.name, Name());
}
ToneProducer::ToneProducer(BMediaAddOn* pAddOn)
: BMediaNode("ToneProducer"),
BBufferProducer(B_MEDIA_RAW_AUDIO),
BControllable(),
BMediaEventLooper(),
mWeb(NULL),
mBufferGroup(NULL),
mLatency(0),
mInternalLatency(0),
mOutputEnabled(true),
mTheta(0.0),
mWaveAscending(true),
mFrequency(440),
mGain(0.25),
mWaveform(SINE_WAVE),
mFramesSent(0),
mStartTime(0),
mGainLastChanged(0),
mFreqLastChanged(0),
mWaveLastChanged(0),
m_pAddOn(pAddOn)
{
// initialize our preferred format object
mPreferredFormat.type = B_MEDIA_RAW_AUDIO;
mPreferredFormat.u.raw_audio.format = media_raw_audio_format::B_AUDIO_FLOAT;
mPreferredFormat.u.raw_audio.frame_rate = 44100; // measured in Hertz
mPreferredFormat.u.raw_audio.byte_order = (B_HOST_IS_BENDIAN) ? B_MEDIA_BIG_ENDIAN : B_MEDIA_LITTLE_ENDIAN;
// we'll use the consumer's preferred buffer size, if any
mPreferredFormat.u.raw_audio.buffer_size = media_raw_audio_format::wildcard.buffer_size;
// 20sep99: multiple-channel support
mPreferredFormat.u.raw_audio.channel_count = media_raw_audio_format::wildcard.channel_count;
// we're not connected yet
mOutput.destination = media_destination::null;
// [e.moon 1dec99]
mOutput.format = mPreferredFormat;
// set up as much information about our output as we can
// +++++ wrong; can't call Node() until the node is registered!
mOutput.source.port = ControlPort();
mOutput.source.id = 0;
mOutput.node = Node();
::strcpy(mOutput.name, "ToneProducer Output");
}
void
ProducerNode::InitializeOutput()
{
out("ConsumerNode::InitializeOutput()\n");
mOutput.source.port = ControlPort();
mOutput.source.id = 0;
mOutput.destination = media_destination::null;
mOutput.node = Node();
mOutput.format.type = B_MEDIA_RAW_AUDIO;
mOutput.format.u.raw_audio = media_raw_audio_format::wildcard;
mOutput.format.u.raw_audio.format = media_raw_audio_format::B_AUDIO_FLOAT;
mOutput.format.u.raw_audio.channel_count = 1;
mOutput.format.u.raw_audio.frame_rate = 44100;
mOutput.format.u.raw_audio.byte_order = (B_HOST_IS_BENDIAN) ? B_MEDIA_BIG_ENDIAN : B_MEDIA_LITTLE_ENDIAN;
strcpy(mOutput.name, "this way out");
}
void
BMediaEventLooper::Quit()
{
CALLED();
if (fRunState == B_TERMINATED)
return;
SetRunState(B_QUITTING);
close_port(ControlPort());
if (fControlThread != -1) {
status_t err;
wait_for_thread(fControlThread, &err);
fControlThread = -1;
}
SetRunState(B_TERMINATED);
}
/* BMediaEventLooper */
void
FireWireDVNode::NodeRegistered()
{
CALLED();
SetPriority(B_REAL_TIME_PRIORITY);
Run();
fOutputEncVideo.node = Node();
fOutputEncVideo.source.port = ControlPort();
fOutputEncVideo.source.id = 0;
fOutputEncVideo.destination = media_destination::null;
fOutputEncVideo.format = fDefaultFormatEncVideo;
strcpy(fOutputEncVideo.name, "encoded video");
RefreshParameterWeb();
}
void
LegacyAudioConsumer::NodeRegistered()
{
mInput.destination.port = ControlPort();
mInput.destination.id = 0;
mInput.source = media_source::null;
mInput.format.type = B_MEDIA_RAW_AUDIO;
mInput.format.u.raw_audio.frame_rate = 44100.0;
mInput.format.u.raw_audio.format = media_raw_audio_format::B_AUDIO_SHORT;
mInput.format.u.raw_audio.channel_count = 2;
mInput.format.u.raw_audio.byte_order = B_MEDIA_HOST_ENDIAN;
mInput.format.u.raw_audio.buffer_size = mBuffer_size;
Run();
}
void
VideoConsumer::NodeRegistered()
{
FUNCTION("VideoConsumer::NodeRegistered\n");
fIn.destination.port = ControlPort();
fIn.destination.id = 0;
fIn.source = media_source::null;
fIn.format.type = B_MEDIA_RAW_VIDEO;
// wild cards yet
fIn.format.u.raw_video = media_raw_video_format::wildcard;
fIn.format.u.raw_video.interlace = 1;
fIn.format.u.raw_video.display.format = B_NO_COLOR_SPACE;
fIn.format.u.raw_video.display.bytes_per_row = 0;
fIn.format.u.raw_video.display.line_width = 0;
fIn.format.u.raw_video.display.line_count = 0;
Run();
}
status_t
AudioConsumer::AcceptFormat(const media_destination& dst,
media_format* format)
{
if (dst.port != ControlPort())
return B_MEDIA_BAD_DESTINATION;
if (format->type == B_MEDIA_UNKNOWN_TYPE)
format->type = B_MEDIA_RAW_AUDIO;
if (format->type != B_MEDIA_RAW_AUDIO)
return B_MEDIA_BAD_FORMAT;
if (format_is_compatible(*format, fFormat))
return B_OK;
*format = fFormat;
return B_MEDIA_BAD_FORMAT;
}
void
ClientNode::EnableOutput(const media_source &src,
bool enabled, int32* _deprecated_)
{
printf("ClientNode::EnableOutput\n");
if (src.id != 0 || src.port != ControlPort())
return;
/* 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->SetEnabled(false);
}
}*/
}
void
LoggingConsumer::NodeRegistered()
{
log_message logMsg;
logMsg.now = TimeSource()->Now();
mLogger->Log(LOG_REGISTERED, logMsg);
// publish our parameter web
mWeb = build_parameter_web();
SetParameterWeb(mWeb);
// Set our priority and start the BMediaEventLooper's thread
SetPriority(mPriority);
Run();
// Initialize as much of our input as we can, now that the Media Kit really "knows" about us
mInput.destination.port = ControlPort();
mInput.destination.id = 0;
mInput.node = Node();
strcpy(mInput.name, "Logged input");
}
void
SoundPlayNode::NodeRegistered()
{
CALLED();
if (fInitStatus != B_OK) {
ReportError(B_NODE_IN_DISTRESS);
return;
}
SetPriority(B_URGENT_PRIORITY);
fOutput.format.type = B_MEDIA_RAW_AUDIO;
fOutput.format.u.raw_audio = media_multi_audio_format::wildcard;
fOutput.destination = media_destination::null;
fOutput.source.port = ControlPort();
fOutput.source.id = 0;
fOutput.node = Node();
strcpy(fOutput.name, Name());
Run();
}
status_t
FireWireDVNode::FormatProposal(const media_source& source,
media_format* format)
{
CALLED();
/* The connection process:
* we are here => BBufferProducer::FormatProposal
* BBufferConsumer::AcceptFormat
* BBufferProducer::PrepareToConnect
* BBufferConsumer::Connected
* BBufferProducer::Connect
*
* What we need to do:
* - if the format contains a wildcard AND we have a requirement for that
* field, set it to the value we need.
* - if a field has a value that is not wildcard and not supported by us,
* we don't change it, and return B_MEDIA_BAD_FORMAT
* - after we are done, the format may still contain wildcards.
*/
if (source.port != ControlPort()) {
fprintf(stderr, "FireWireDVNode::FormatProposal returning "
"B_MEDIA_BAD_SOURCE\n");
return B_MEDIA_BAD_SOURCE;
}
media_type requestedType = format->type;
*format = fDefaultFormatEncVideo;
if (requestedType != B_MEDIA_UNKNOWN_TYPE
&& requestedType != B_MEDIA_ENCODED_VIDEO) {
fprintf(stderr, "FireWireDVNode::FormatProposal returning "
"B_MEDIA_BAD_FORMAT\n");
return B_MEDIA_BAD_FORMAT;
}
// encoded video or wildcard type, either is okay by us
return B_OK;
}
void
FinePixProducer::NodeRegistered()
{
if (fInitStatus != B_OK) {
ReportError(B_NODE_IN_DISTRESS);
return;
}
fOutput.node = Node();
fOutput.source.port = ControlPort();
fOutput.source.id = 0;
fOutput.destination = media_destination::null;
strcpy(fOutput.name, Name());
/* Tailor these for the output of your device */
fOutput.format.type = B_MEDIA_RAW_VIDEO;
fOutput.format.u.raw_video = media_raw_video_format::wildcard;
fOutput.format.u.raw_video.interlace = 1;
fOutput.format.u.raw_video.display.format = B_RGB32;
/* Start the BMediaEventLooper control loop running */
Run();
}
status_t
ClientNode::FormatProposal(const media_source &src,
media_format *format)
{
printf("ClientNode::FormatProposal\n");
if (src.id != 0 || src.port != ControlPort())
return B_MEDIA_BAD_SOURCE;
media_raw_audio_format* raw = &format->u.raw_audio;
if (format->type == B_MEDIA_UNKNOWN_TYPE) {
format->type = B_MEDIA_RAW_AUDIO;
} else if (format->type != B_MEDIA_RAW_AUDIO ||
format->u.raw_audio.format != WRAPPER_PREFERRED_FORMAT)
return B_MEDIA_BAD_FORMAT;
if (raw->format == 0)
raw->format = fFormat.u.raw_audio.format;
if (raw->frame_rate == 0)
raw->frame_rate = fFormat.u.raw_audio.frame_rate;
if (raw->buffer_size == 0)
raw->buffer_size = fFormat.u.raw_audio.buffer_size;
if (raw->channel_count == 0)
raw->channel_count = fFormat.u.raw_audio.channel_count;
if (format->u.raw_audio.channel_count > 1
|| raw->frame_rate != fFormat.u.raw_audio.frame_rate
|| raw->buffer_size != fFormat.u.raw_audio.buffer_size)
return B_MEDIA_BAD_FORMAT;
return B_OK;
}
void
ClientNode::LatencyChanged(const media_source &src,
const media_destination &dst,
bigtime_t latency, uint32 flags)
{
printf("ClientNode::LatencyChanged\n");
if (src.port != ControlPort() || src.id != 0) {
printf("Error: wrong source");
return;
}
fDownstreamLatency = latency;
SetEventLatency(fDownstreamLatency + fProcessLatency);
/*media_input* input;
JackPortList* inputs = fOwner->GetInputPorts();
for (int i = 0; i < inputs->CountItems(); i++) {
input = inputs->ItemAt(i)->MediaInput();
// consumer disabled
//SendLatencyChange(input->source,
// input->destination, EventLatency());
}*/
}
void
VideoProducer::NodeRegistered()
{
if (fInitStatus != B_OK) {
ReportError(B_NODE_IN_DISTRESS);
return;
}
/* Set up the parameter web */
//TODO: remove and put sensible stuff there
BParameterWeb *web = new BParameterWeb();
BParameterGroup *main = web->MakeGroup(Name());
BParameterGroup *g;
/*
g = main->MakeGroup("Color");
BDiscreteParameter *state = g->MakeDiscreteParameter(
P_COLOR, B_MEDIA_RAW_VIDEO, "Color", "Color");
state->AddItem(B_HOST_TO_LENDIAN_INT32(0x00ff0000), "Red");
state->AddItem(B_HOST_TO_LENDIAN_INT32(0x0000ff00), "Green");
state->AddItem(B_HOST_TO_LENDIAN_INT32(0x000000ff), "Blue");
*/
BParameter *p;
g = main->MakeGroup("Info");
p = g->MakeTextParameter(
P_INFO, B_MEDIA_RAW_VIDEO, "", "Info", 256);
int32 id = P_LAST;
if (fCamDevice) {
#ifndef SINGLE_PARAMETER_GROUP
main = web->MakeGroup("Device");
#endif
fCamDevice->AddParameters(main, id);
if (fCamDevice->Sensor()) {
#ifndef SINGLE_PARAMETER_GROUP
main = web->MakeGroup("Sensor");
#endif
fCamDevice->Sensor()->AddParameters(main, id);
}
}
fColor = B_HOST_TO_LENDIAN_INT32(0x00ff0000);
fLastColorChange = system_time();
/* After this call, the BControllable owns the BParameterWeb object and
* will delete it for you */
SetParameterWeb(web);
fOutput.node = Node();
fOutput.source.port = ControlPort();
fOutput.source.id = 0;
fOutput.destination = media_destination::null;
strcpy(fOutput.name, Name());
/* Tailor these for the output of your device */
fOutput.format.type = B_MEDIA_RAW_VIDEO;
fOutput.format.u.raw_video = media_raw_video_format::wildcard;
fOutput.format.u.raw_video.interlace = 1;
fOutput.format.u.raw_video.display.format = B_RGB32;
fOutput.format.u.raw_video.field_rate = FIELD_RATE; // XXX: mmu
/* Start the BMediaEventLooper control loop running */
Run();
}
