/* * Copyright 2004-2008, François Revol, . * Distributed under the terms of the MIT License. */ #include #include #include #include #include #include #include #include #include #include #include #include #include //XXX: change interface #include #include "CamDevice.h" #include "CamSensor.h" // don't separate parameters from addon, device and sensor #define SINGLE_PARAMETER_GROUP 1 // CodyCam and eXposer prefer 320x240 #define FORCE_320_240 1 //#define FORCE_160_120 1 //#define FORCE_MAX_FRAME 1 #define TOUCH(x) ((void)(x)) #define PRINTF(a,b) \ do { \ if (a < 2) { \ printf("VideoProducer::"); \ printf b; \ } \ } while (0) #include "Producer.h" //#define FIELD_RATE 30.f //#define FIELD_RATE 29.97f #define FIELD_RATE 5.f int32 VideoProducer::fInstances = 0; VideoProducer::VideoProducer( BMediaAddOn *addon, CamDevice *dev, const char *name, int32 internal_id) : BMediaNode(name), BMediaEventLooper(), BBufferProducer(B_MEDIA_RAW_VIDEO), BControllable() { // status_t err; fInitStatus = B_NO_INIT; /* Only allow one instance of the node to exist at any time */ if (atomic_add(&fInstances, 1) != 0) return; fInternalID = internal_id; fAddOn = addon; fCamDevice = dev; fBufferGroup = NULL; fThread = -1; fFrameSync = -1; fProcessingLatency = 0LL; fRunning = false; fConnected = false; fEnabled = false; fOutput.destination = media_destination::null; AddNodeKind(B_PHYSICAL_INPUT); fInitStatus = B_OK; return; } VideoProducer::~VideoProducer() { if (fInitStatus == B_OK) { /* Clean up after ourselves, in case the application didn't make us * do so. */ if (fConnected) Disconnect(fOutput.source, fOutput.destination); if (fRunning) HandleStop(); } atomic_add(&fInstances, -1); } /* BMediaNode */ port_id VideoProducer::ControlPort() const { return BMediaNode::ControlPort(); } BMediaAddOn * VideoProducer::AddOn(int32 *internal_id) const { if (internal_id) *internal_id = fInternalID; return fAddOn; } status_t VideoProducer::HandleMessage(int32 /*message*/, const void* /*data*/, size_t /*size*/) { return B_ERROR; } void VideoProducer::Preroll() { /* This hook may be called before the node is started to give the hardware * a chance to start. */ } void VideoProducer::SetTimeSource(BTimeSource* /*time_source*/) { /* Tell frame generation thread to recalculate delay value */ release_sem(fFrameSync); } status_t VideoProducer::RequestCompleted(const media_request_info &info) { return BMediaNode::RequestCompleted(info); } /* BMediaEventLooper */ 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(); } void VideoProducer::Start(bigtime_t performance_time) { BMediaEventLooper::Start(performance_time); } void VideoProducer::Stop(bigtime_t performance_time, bool immediate) { BMediaEventLooper::Stop(performance_time, immediate); } void VideoProducer::Seek(bigtime_t media_time, bigtime_t performance_time) { BMediaEventLooper::Seek(media_time, performance_time); } void VideoProducer::TimeWarp(bigtime_t at_real_time, bigtime_t to_performance_time) { BMediaEventLooper::TimeWarp(at_real_time, to_performance_time); } status_t VideoProducer::AddTimer(bigtime_t at_performance_time, int32 cookie) { return BMediaEventLooper::AddTimer(at_performance_time, cookie); } void VideoProducer::SetRunMode(run_mode mode) { BMediaEventLooper::SetRunMode(mode); } void VideoProducer::HandleEvent(const media_timed_event *event, bigtime_t lateness, bool realTimeEvent) { TOUCH(lateness); TOUCH(realTimeEvent); switch(event->type) { case BTimedEventQueue::B_START: HandleStart(event->event_time); break; case BTimedEventQueue::B_STOP: HandleStop(); break; case BTimedEventQueue::B_WARP: HandleTimeWarp(event->bigdata); break; case BTimedEventQueue::B_SEEK: HandleSeek(event->bigdata); break; case BTimedEventQueue::B_HANDLE_BUFFER: case BTimedEventQueue::B_DATA_STATUS: case BTimedEventQueue::B_PARAMETER: default: PRINTF(-1, ("HandleEvent: Unhandled event -- %" B_PRIx32 "\n", event->type)); break; } } void VideoProducer::CleanUpEvent(const media_timed_event *event) { BMediaEventLooper::CleanUpEvent(event); } bigtime_t VideoProducer::OfflineTime() { return BMediaEventLooper::OfflineTime(); } void VideoProducer::ControlLoop() { BMediaEventLooper::ControlLoop(); } status_t VideoProducer::DeleteHook(BMediaNode * node) { return BMediaEventLooper::DeleteHook(node); } /* BBufferProducer */ status_t VideoProducer::FormatSuggestionRequested( media_type type, int32 quality, media_format *format) { if (type != B_MEDIA_ENCODED_VIDEO) return B_MEDIA_BAD_FORMAT; TOUCH(quality); PRINTF(1, ("FormatSuggestionRequested() %" B_PRIu32 "x%" B_PRIu32 "\n", \ format->u.raw_video.display.line_width, \ format->u.raw_video.display.line_count)); *format = fOutput.format; uint32 width, height; if (fCamDevice && fCamDevice->SuggestVideoFrame(width, height) == B_OK) { format->u.raw_video.display.line_width = width; format->u.raw_video.display.line_count = height; } format->u.raw_video.field_rate = FIELD_RATE; return B_OK; } status_t VideoProducer::FormatProposal(const media_source &output, media_format *format) { status_t err; if (!format) return B_BAD_VALUE; if (output != fOutput.source) return B_MEDIA_BAD_SOURCE; PRINTF(1, ("FormatProposal() %" B_PRIu32 "x%" B_PRIu32 "\n", \ format->u.raw_video.display.line_width, \ format->u.raw_video.display.line_count)); err = format_is_compatible(*format, fOutput.format) ? B_OK : B_MEDIA_BAD_FORMAT; uint32 width = format->u.raw_video.display.line_width; uint32 height = format->u.raw_video.display.line_count; *format = fOutput.format; if (err == B_OK && fCamDevice) { err = fCamDevice->AcceptVideoFrame(width, height); if (err >= B_OK) { format->u.raw_video.display.line_width = width; format->u.raw_video.display.line_count = height; } } PRINTF(1, ("FormatProposal: %" B_PRIu32 "x%" B_PRIu32 "\n", \ format->u.raw_video.display.line_width, \ format->u.raw_video.display.line_count)); return err; } status_t VideoProducer::FormatChangeRequested(const media_source &source, const media_destination &destination, media_format *io_format, int32 *_deprecated_) { TOUCH(destination); TOUCH(io_format); TOUCH(_deprecated_); if (source != fOutput.source) return B_MEDIA_BAD_SOURCE; return B_ERROR; } status_t VideoProducer::GetNextOutput(int32 *cookie, media_output *out_output) { if (!out_output) return B_BAD_VALUE; if ((*cookie) != 0) return B_BAD_INDEX; *out_output = fOutput; (*cookie)++; return B_OK; } status_t VideoProducer::DisposeOutputCookie(int32 cookie) { TOUCH(cookie); return B_OK; } status_t VideoProducer::SetBufferGroup(const media_source &for_source, BBufferGroup *group) { TOUCH(for_source); TOUCH(group); return B_ERROR; } status_t VideoProducer::VideoClippingChanged(const media_source &for_source, int16 num_shorts, int16 *clip_data, const media_video_display_info &display, int32 *_deprecated_) { TOUCH(for_source); TOUCH(num_shorts); TOUCH(clip_data); TOUCH(display); TOUCH(_deprecated_); return B_ERROR; } status_t VideoProducer::GetLatency(bigtime_t *out_latency) { *out_latency = EventLatency() + SchedulingLatency(); return B_OK; } status_t VideoProducer::PrepareToConnect(const media_source &source, const media_destination &destination, media_format *format, media_source *out_source, char *out_name) { status_t err; PRINTF(1, ("PrepareToConnect() %" B_PRIu32 "x%" B_PRIu32 "\n", \ format->u.raw_video.display.line_width, \ format->u.raw_video.display.line_count)); if (fConnected) { PRINTF(0, ("PrepareToConnect: Already connected\n")); return EALREADY; } if (source != fOutput.source) return B_MEDIA_BAD_SOURCE; if (fOutput.destination != media_destination::null) return B_MEDIA_ALREADY_CONNECTED; /* The format parameter comes in with the suggested format, and may be * specialized as desired by the node */ if (!format_is_compatible(*format, fOutput.format)) { *format = fOutput.format; return B_MEDIA_BAD_FORMAT; } //XXX:FIXME #if 0 // if (format->u.raw_video.display.line_width == 0) format->u.raw_video.display.line_width = 352;//320; format->u.raw_video.display.line_width = 320; // if (format->u.raw_video.display.line_count == 0) format->u.raw_video.display.line_count = 288;//240; format->u.raw_video.display.line_count = 240; #endif #ifdef FORCE_320_240 { format->u.raw_video.display.line_width = 320; format->u.raw_video.display.line_count = 240; } #endif #ifdef FORCE_160_120 { format->u.raw_video.display.line_width = 160; format->u.raw_video.display.line_count = 120; } #endif #ifdef FORCE_MAX_FRAME { format->u.raw_video.display.line_width = 0; format->u.raw_video.display.line_count = 0; } #endif if (fCamDevice) { err = fCamDevice->AcceptVideoFrame( format->u.raw_video.display.line_width, format->u.raw_video.display.line_count); if (err < B_OK) return err; } if (format->u.raw_video.field_rate == 0) format->u.raw_video.field_rate = FIELD_RATE; *out_source = fOutput.source; strcpy(out_name, fOutput.name); fOutput.destination = destination; return B_OK; } void VideoProducer::Connect(status_t error, const media_source &source, const media_destination &destination, const media_format &format, char *io_name) { PRINTF(1, ("Connect() %" B_PRIu32 "x%" B_PRIu32 "\n", \ format.u.raw_video.display.line_width, \ format.u.raw_video.display.line_count)); if (fConnected) { PRINTF(0, ("Connect: Already connected\n")); return; } BAutolock lock(fCamDevice->Locker()); if (!fCamDevice->IsPlugged()) { PRINTF(0, ("Connect: Device unplugged\n")); return; } if (source != fOutput.source || error < B_OK || !const_cast(&format)->Matches(&fOutput.format)) { PRINTF(1, ("Connect: Connect error\n")); return; } fOutput.destination = destination; strcpy(io_name, fOutput.name); if (fOutput.format.u.raw_video.field_rate != 0.0f) { fPerformanceTimeBase = fPerformanceTimeBase + (bigtime_t) ((fFrame - fFrameBase) * (1000000 / fOutput.format.u.raw_video.field_rate)); fFrameBase = fFrame; } fConnectedFormat = format.u.raw_video; /* get the latency */ bigtime_t latency = 0; media_node_id tsID = 0; FindLatencyFor(fOutput.destination, &latency, &tsID); #define NODE_LATENCY 1000 SetEventLatency(latency + NODE_LATENCY); uint32 *buffer, *p, f = 3; p = buffer = (uint32 *)malloc(4 * fConnectedFormat.display.line_count * fConnectedFormat.display.line_width); if (!buffer) { PRINTF(0, ("Connect: Out of memory\n")); return; } bigtime_t now = system_time(); for (uint32 y=0;yInitCheck() < B_OK) { delete fBufferGroup; fBufferGroup = NULL; return; } fConnected = true; fEnabled = true; /* Tell frame generation thread to recalculate delay value */ release_sem(fFrameSync); } void VideoProducer::Disconnect(const media_source &source, const media_destination &destination) { PRINTF(1, ("Disconnect()\n")); if (!fConnected) { PRINTF(0, ("Disconnect: Not connected\n")); return; } if ((source != fOutput.source) || (destination != fOutput.destination)) { PRINTF(0, ("Disconnect: Bad source and/or destination\n")); return; } #if 1 /* Some dumb apps don't stop nodes before disconnecting... */ if (fRunning) HandleStop(); #endif fEnabled = false; fOutput.destination = media_destination::null; fLock.Lock(); delete fBufferGroup; fBufferGroup = NULL; fLock.Unlock(); fConnected = false; } void VideoProducer::LateNoticeReceived(const media_source &source, bigtime_t how_much, bigtime_t performance_time) { TOUCH(source); TOUCH(how_much); TOUCH(performance_time); } void VideoProducer::EnableOutput(const media_source &source, bool enabled, int32 *_deprecated_) { TOUCH(_deprecated_); if (source != fOutput.source) return; fEnabled = enabled; } status_t VideoProducer::SetPlayRate(int32 numer, int32 denom) { TOUCH(numer); TOUCH(denom); return B_ERROR; } void VideoProducer::AdditionalBufferRequested(const media_source &source, media_buffer_id prev_buffer, bigtime_t prev_time, const media_seek_tag *prev_tag) { TOUCH(source); TOUCH(prev_buffer); TOUCH(prev_time); TOUCH(prev_tag); } void VideoProducer::LatencyChanged(const media_source &source, const media_destination &destination, bigtime_t new_latency, uint32 flags) { TOUCH(source); TOUCH(destination); TOUCH(new_latency); TOUCH(flags); } /* BControllable */ status_t VideoProducer::GetParameterValue( int32 id, bigtime_t *last_change, void *value, size_t *size) { status_t err; switch (id) { case P_COLOR: //return B_BAD_VALUE; *last_change = fLastColorChange; *size = sizeof(uint32); *((uint32 *)value) = fColor; return B_OK; case P_INFO: if (*size < (size_t)(fInfoString.Length() + 1)) return EINVAL; *last_change = fLastColorChange; *size = fInfoString.Length() + 1; memcpy(value, fInfoString.String(), *size); return B_OK; } if (fCamDevice) { BAutolock lock(fCamDevice->Locker()); err = fCamDevice->GetParameterValue(id, last_change, value, size); if (err >= B_OK) return err; if (fCamDevice->Sensor()) { err = fCamDevice->Sensor()->GetParameterValue(id, last_change, value, size); if (err >= B_OK) return err; } } return B_BAD_VALUE; } void VideoProducer::SetParameterValue( int32 id, bigtime_t when, const void *value, size_t size) { status_t err = B_OK; switch (id) { case P_COLOR: if (!value || (size != sizeof(uint32))) return; if (*(uint32 *)value == fColor) return; fColor = *(uint32 *)value; fLastColorChange = when; break; case P_INFO: // forbidden return; default: if (fCamDevice == NULL) return; BAutolock lock(fCamDevice->Locker()); err = fCamDevice->SetParameterValue(id, when, value, size); if ((err < B_OK) && (fCamDevice->Sensor())) { err = fCamDevice->Sensor()->SetParameterValue(id, when, value, size); } } if (err >= B_OK) BroadcastNewParameterValue(when, id, (void *)value, size); } status_t VideoProducer::StartControlPanel(BMessenger *out_messenger) { return BControllable::StartControlPanel(out_messenger); } /* VideoProducer */ void VideoProducer::HandleStart(bigtime_t performance_time) { /* Start producing frames, even if the output hasn't been connected yet. */ PRINTF(1, ("HandleStart(%" B_PRIdBIGTIME ")\n", performance_time)); if (fRunning) { PRINTF(-1, ("HandleStart: Node already started\n")); return; } fFrame = 0; fFrameBase = 0; fPerformanceTimeBase = performance_time; fFrameSync = create_sem(0, "frame synchronization"); if (fFrameSync < B_OK) goto err1; fThread = spawn_thread(_frame_generator_, "frame generator", B_NORMAL_PRIORITY, this); if (fThread < B_OK) goto err2; resume_thread(fThread); { BAutolock lock(fCamDevice->Locker()); fCamDevice->StartTransfer(); } fRunning = true; return; err2: delete_sem(fFrameSync); err1: return; } void VideoProducer::HandleStop(void) { PRINTF(1, ("HandleStop()\n")); if (!fRunning) { PRINTF(-1, ("HandleStop: Node isn't running\n")); return; } delete_sem(fFrameSync); wait_for_thread(fThread, &fThread); BAutolock lock(fCamDevice->Locker()); fCamDevice->StopTransfer(); fRunning = false; } void VideoProducer::HandleTimeWarp(bigtime_t performance_time) { fPerformanceTimeBase = performance_time; fFrameBase = fFrame; /* Tell frame generation thread to recalculate delay value */ release_sem(fFrameSync); } void VideoProducer::HandleSeek(bigtime_t performance_time) { fPerformanceTimeBase = performance_time; fFrameBase = fFrame; /* Tell frame generation thread to recalculate delay value */ release_sem(fFrameSync); } void VideoProducer::_UpdateStats() { float fps = (fStats[0].frames - fStats[1].frames) * 1000000LL / (double)(fStats[0].stamp - fStats[1].stamp); float rfps = (fStats[0].actual - fStats[1].actual) * 1000000LL / (double)(fStats[0].stamp - fStats[1].stamp); fInfoString = "FPS: "; fInfoString << fps << " virt, " << rfps << " real, missed: " << fStats[0].missed; memcpy(&fStats[1], &fStats[0], sizeof(fStats[0])); fLastColorChange = system_time(); BroadcastNewParameterValue(fLastColorChange, P_INFO, (void *)fInfoString.String(), fInfoString.Length()+1); } /* The following functions form the thread that generates frames. You should * replace this with the code that interfaces to your hardware. */ int32 VideoProducer::FrameGenerator() { bigtime_t wait_until = system_time(); while (1) { PRINTF(1, ("FrameGenerator: " \ "acquire_sem_etc() until %" B_PRIdBIGTIME "µs " \ "(in %" B_PRIdBIGTIME "µs)\n", \ wait_until, wait_until - system_time())); status_t err = acquire_sem_etc(fFrameSync, 1, B_ABSOLUTE_TIMEOUT, wait_until); /* The only acceptable responses are B_OK and B_TIMED_OUT. Everything * else means the thread should quit. Deleting the semaphore, as in * VideoProducer::HandleStop(), will trigger this behavior. */ if ((err != B_OK) && (err != B_TIMED_OUT)) break; fFrame++; /* Recalculate the time until the thread should wake up to begin * processing the next frame. Subtract fProcessingLatency so that * the frame is sent in time. */ wait_until = TimeSource()->RealTimeFor(fPerformanceTimeBase, 0) + (bigtime_t) ((fFrame - fFrameBase) * (1000000 / fConnectedFormat.field_rate)) - fProcessingLatency; PRINT(("PS: %" B_PRIdBIGTIME "\n", fProcessingLatency)); /* Drop frame if it's at least a frame late */ if (wait_until < system_time()) continue; PRINTF(1, ("FrameGenerator: wait until %" B_PRIdBIGTIME ", " "%ctimed out, %crunning, %cenabled.\n", wait_until, (err == B_OK)?'!':' ', (fRunning)?' ':'!', (fEnabled)?' ':'!')); /* If the semaphore was acquired successfully, it means something * changed the timing information (see VideoProducer::Connect()) and * so the thread should go back to sleep until the newly-calculated * wait_until time. */ if (err == B_OK) continue; /* Send buffers only if the node is running and the output has been * enabled */ if (!fRunning || !fEnabled) continue; BAutolock _(fLock); /* Fetch a buffer from the buffer group */ BBuffer *buffer = fBufferGroup->RequestBuffer( 4 * fConnectedFormat.display.line_width * fConnectedFormat.display.line_count, 0LL); if (!buffer) continue; /* Fill out the details about this buffer. */ media_header *h = buffer->Header(); h->type = B_MEDIA_RAW_VIDEO; h->time_source = TimeSource()->ID(); h->size_used = 4 * fConnectedFormat.display.line_width * fConnectedFormat.display.line_count; /* For a buffer originating from a device, you might want to calculate * this based on the PerformanceTimeFor the time your buffer arrived at * the hardware (plus any applicable adjustments). */ /* h->start_time = fPerformanceTimeBase + (bigtime_t) ((fFrame - fFrameBase) * (1000000 / fConnectedFormat.field_rate)); */ h->file_pos = 0; h->orig_size = 0; h->data_offset = 0; h->u.raw_video.field_gamma = 1.0; h->u.raw_video.field_sequence = fFrame; h->u.raw_video.field_number = 0; h->u.raw_video.pulldown_number = 0; h->u.raw_video.first_active_line = 1; h->u.raw_video.line_count = fConnectedFormat.display.line_count; // This is where we fill the video buffer. #if 0 uint32 *p = (uint32 *)buffer->Data(); /* Fill in a pattern */ for (uint32 y=0;yLocker()); bigtime_t now = system_time(); bigtime_t stamp; //#ifdef UseFillFrameBuffer err = fCamDevice->FillFrameBuffer(buffer, &stamp); if (err < B_OK) { ;//XXX handle error fStats[0].missed++; } //#endif #ifdef UseGetFrameBitmap BBitmap *bm; err = fCamDevice->GetFrameBitmap(&bm, &stamp); if (err >= B_OK) { ;//XXX handle error fStats[0].missed++; } #endif fStats[0].frames = fFrame; fStats[0].actual++;; fStats[0].stamp = system_time(); //PRINTF(1, ("FrameGenerator: stamp %lld vs %lld\n", stamp, h->start_time)); //XXX: that's what we should be doing, but CodyCam drops all frames as they are late. (maybe add latency ??) //h->start_time = TimeSource()->PerformanceTimeFor(stamp); h->start_time = TimeSource()->PerformanceTimeFor(system_time()); // update processing latency // XXX: should I ?? fProcessingLatency = system_time() - now; fProcessingLatency /= 10; PRINTF(1, ("FrameGenerator: SendBuffer...\n")); /* Send the buffer on down to the consumer */ if (SendBuffer(buffer, fOutput.source, fOutput.destination) < B_OK) { PRINTF(-1, ("FrameGenerator: Error sending buffer\n")); /* If there is a problem sending the buffer, return it to its * buffer group. */ buffer->Recycle(); } _UpdateStats(); } PRINTF(1, ("FrameGenerator: thread existed.\n")); return B_OK; } int32 VideoProducer::_frame_generator_(void *data) { return ((VideoProducer *)data)->FrameGenerator(); }