bool linuxfwCamera::startCamera() {
if (dc1394_start_iso_transmission(handle,camera.node) !=DC1394_SUCCESS) {
fprintf( stderr, "unable to start camera iso transmission\n");
dc1394_dma_release_camera(handle,&camera);
dc1394_destroy_handle(handle);
return false;
}
return true;
}
static int dc1394_v1_read_header(AVFormatContext *c, AVFormatParameters * ap)
{
dc1394_data* dc1394 = c->priv_data;
AVStream* vst;
nodeid_t* camera_nodes;
int res;
struct dc1394_frame_format *fmt = NULL;
struct dc1394_frame_rate *fps = NULL;
if (dc1394_read_common(c,ap,&fmt,&fps) != 0)
return -1;
/* Now let us prep the hardware. */
dc1394->handle = dc1394_create_handle(0); /* FIXME: gotta have ap->port */
if (!dc1394->handle) {
av_log(c, AV_LOG_ERROR, "Can't acquire dc1394 handle on port %d\n", 0 /* ap->port */);
goto out;
}
camera_nodes = dc1394_get_camera_nodes(dc1394->handle, &res, 1);
if (!camera_nodes || camera_nodes[ap->channel] == DC1394_NO_CAMERA) {
av_log(c, AV_LOG_ERROR, "There's no IIDC camera on the channel %d\n", ap->channel);
goto out_handle;
}
res = dc1394_dma_setup_capture(dc1394->handle, camera_nodes[ap->channel],
0,
FORMAT_VGA_NONCOMPRESSED,
fmt->frame_size_id,
SPEED_400,
fps->frame_rate_id, 8, 1,
c->filename,
&dc1394->camera);
dc1394_free_camera_nodes(camera_nodes);
if (res != DC1394_SUCCESS) {
av_log(c, AV_LOG_ERROR, "Can't prepare camera for the DMA capture\n");
goto out_handle;
}
res = dc1394_start_iso_transmission(dc1394->handle, dc1394->camera.node);
if (res != DC1394_SUCCESS) {
av_log(c, AV_LOG_ERROR, "Can't start isochronous transmission\n");
goto out_handle_dma;
}
return 0;
out_handle_dma:
dc1394_dma_unlisten(dc1394->handle, &dc1394->camera);
dc1394_dma_release_camera(dc1394->handle, &dc1394->camera);
out_handle:
dc1394_destroy_handle(dc1394->handle);
out:
return -1;
}
//---------------------------------------------------------------
void
Device1394::initCapture()
{
unsigned int channel;
unsigned int speed;
if (dc1394_get_iso_channel_and_speed(handle_, p_camera_->node, &channel, &speed) != DC1394_SUCCESS)
throw Miro::Exception("Device1394:initDevice: unable to get iso channel number");
MIRO_DBG_OSTR(VIDEO, LL_DEBUG,
"ISO channel: " << channel << " speed: " << speed);
channel = 1;
#if ( LIBDC1394_VERSION == 1 )
// old version
if (dc1394_dma_setup_capture(handle_,
p_camera_->node,
channel,
FORMAT_VGA_NONCOMPRESSED,
imageFormat_,
SPEED_400,
frameRate_,
NUM_BUFFERS,
DROP_FRAMES,
params_.device.c_str(),
p_camera_) != DC1394_SUCCESS)
#elif ( LIBDC1394_VERSION == 2 )
// new version
if (dc1394_dma_setup_capture(handle_,
p_camera_->node,
channel,
FORMAT_VGA_NONCOMPRESSED,
imageFormat_,
SPEED_400,
frameRate_,
NUM_BUFFERS,
1,
DROP_FRAMES,
params_.device.c_str(),
p_camera_) != DC1394_SUCCESS)
#endif
throw Miro::Exception("Device1394::handleConnect: unable to setup camera");
if (dc1394_start_iso_transmission(handle_, p_camera_->node) != DC1394_SUCCESS)
throw Miro::Exception("Device1394::handleConnect: unable to start camera iso transmission");
is_open_ = true;
}
static int cam_setup( struct dc1394_input *conf, int cam, int port,
nodeid_t node, int dma_chan )
{
unsigned int channel;
unsigned int speed;
conf->cam[cam].running = 0;
conf->camera[cam].node = node;
conf->cam[cam].handle = dc1394_create_handle( port );
if( ! conf->cam[cam].handle )
{
spook_log( SL_ERR, "dc1394: unable to create a camera handle" );
return -1;
}
if( dc1394_get_iso_channel_and_speed( conf->cam[cam].handle, node,
&channel, &speed ) != DC1394_SUCCESS )
{
spook_log( SL_ERR, "dc1394: unable to create an ISO channel" );
return -1;
}
if( dc1394_dma_setup_capture( conf->cam[cam].handle, node, dma_chan,
FORMAT_VGA_NONCOMPRESSED, MODE_320x240_YUV422,
SPEED_400, FRAMERATE_30, 8 /* num buffers */,
#ifdef DC1394_EXTRA_BUFFERING_FLAG
0 /* do_extra_buffering */,
#endif
1 /* drop frames */, NULL /* device name */,
&conf->camera[cam] ) != DC1394_SUCCESS )
{
spook_log( SL_ERR, "dc1394: unable to set up DMA for camera" );
return -1;
}
if( dc1394_start_iso_transmission( conf->cam[cam].handle,
conf->camera[cam].node ) != DC1394_SUCCESS )
{
spook_log( SL_ERR,
"dc1394: unable to start ISO transfer from camera" );
return -1;
}
conf->cam[cam].outq = new_soft_queue( 16 );
add_softqueue_event( conf->cam[cam].outq, 0,
get_back_frame, &conf->cam[cam] );
return 0;
}
// Setup camera to use given dc1394 mode
static int
icvSetModeCAM_DC1394( CvCaptureCAM_DC1394 * capture, int mode ){
quadlet_t modes, formats;
//printf("<icvSetModeCAM_DC1394>\n");
// figure out corrent format for this mode
int format = (mode - MODE_FORMAT0_MIN) / 32 + FORMAT_MIN;
// get supported formats
if (dc1394_query_supported_formats(capture->handle, capture->camera->node, &formats)<0) {
fprintf(stderr,"%s:%d: Could not query supported formats\n",__FILE__,__LINE__);
return 0;
}
// is format for requested mode supported ?
if(icvFormatSupportedCAM_DC1394(format, formats)==0){
return 0;
}
// get supported modes for requested format
if (dc1394_query_supported_modes(capture->handle, capture->camera->node, format, &modes)<0){
fprintf(stderr,"%s:%d: Could not query supported modes for format %d\n",__FILE__,__LINE__, capture->format);
return 0;
}
// is requested mode supported ?
if(! icvModeSupportedCAM_DC1394(format, mode, modes) ){
return 0;
}
int color_mode = icvColorMode( mode );
if(color_mode == -1){
return 0;
}
int frame_rate = icvGetBestFrameRate(capture, format, mode);
dc1394_dma_unlisten(capture->handle, capture->camera);
if (dc1394_dma_setup_capture(capture->handle, capture->camera->node, capture->camera->channel /*channel*/,
format, mode, SPEED_400,
frame_rate, NUM_BUFFERS,
#ifdef HAVE_DC1394_095
0 /*do_extra_buffering*/,
#endif
1 /*DROP_FRAMES*/,
capture->device_name, capture->camera) != DC1394_SUCCESS) {
fprintf(stderr,"%s:%d: Failed to setup DMA capture with VIDEO1394\n",__FILE__,__LINE__);
return 0;
}
dc1394_start_iso_transmission(capture->handle, capture->camera->node);
capture->frame_rate = frame_rate;
capture->format = format;
capture->mode = mode;
capture->color_mode = color_mode;
// now fix image size to match new mode
icvResizeFrame( capture );
return 1;
}
CvCapture * cvCaptureFromCAM_DC1394 (int index)
{
quadlet_t modes[8], formats;
int i;
if (numPorts<0) icvInitCapture_DC1394();
if (numPorts==0)
return 0; /* No i1394 ports found */
if (numCameras<1)
return 0;
if (index>=numCameras)
return 0;
if (index<0)
return 0;
CvCaptureCAM_DC1394 * pcap = (CvCaptureCAM_DC1394*)cvAlloc(sizeof(CvCaptureCAM_DC1394));
pcap->vtable = &captureCAM_DC1394_vtable;
/* Select a port and camera */
pcap->device_name = videodev[cameras[index].portnum];
pcap->handle = handles[cameras[index].portnum];
pcap->camera = &cameras[index].cam;
// get supported formats
if (dc1394_query_supported_formats(pcap->handle, pcap->camera->node, &formats)<0) {
fprintf(stderr,"%s:%d: Could not query supported formats\n",__FILE__,__LINE__);
formats=0x0;
}
for (i=0; i < NUM_FORMATS; i++) {
modes[i]=0;
if (icvFormatSupportedCAM_DC1394(i+FORMAT_MIN, formats)){
if (dc1394_query_supported_modes(pcap->handle, pcap->camera->node, i+FORMAT_MIN, &modes[i])<0) {
fprintf(stderr,"%s:%d: Could not query Format%d modes\n",__FILE__,__LINE__,i);
}
}
}
pcap->format = 0;
pcap->mode = 0;
pcap->color_mode = 0;
pcap->frame_rate = 0;
int format_idx = -1;
// scan the list of preferred modes, and find a supported one
for(i=0; (pcap->mode == 0) && (preferred_modes[i] != 0); i++) {
if((preferred_modes[i] >= FORMAT_MIN) && (preferred_modes[i] <= FORMAT_MAX)) {
pcap->format = preferred_modes[i];
format_idx = preferred_modes[i] - FORMAT_MIN;
continue;
}
assert(format_idx != -1);
if ( ! icvFormatSupportedCAM_DC1394(pcap->format, formats) )
continue;
if ( icvModeSupportedCAM_DC1394(pcap->format, preferred_modes[i], modes[format_idx]) ){
pcap->mode = preferred_modes[i];
}
}
if (pcap->mode == 0) {
fprintf(stderr,"%s:%d: Could not find a supported mode for this camera\n",__FILE__,__LINE__);
goto ERROR;
}
pcap->color_mode = icvColorMode( pcap->mode );
if( pcap->color_mode == -1){
fprintf(stderr,"%s:%d: ERROR: BPP is Unsupported!!\n",__FILE__,__LINE__);
goto ERROR;
}
// set frame rate to optimal value given format and mode
pcap->frame_rate = icvGetBestFrameRate(pcap, pcap->format, pcap->mode);
if (pcap->format!=FORMAT_SCALABLE_IMAGE_SIZE) { // everything except Format 7
if (dc1394_dma_setup_capture(pcap->handle, pcap->camera->node, index+1 /*channel*/,
pcap->format, pcap->mode, SPEED_400,
pcap->frame_rate, NUM_BUFFERS,
#ifdef HAVE_DC1394_095
0 /*do_extra_buffering*/,
#endif
1 /*DROP_FRAMES*/,
pcap->device_name, pcap->camera) != DC1394_SUCCESS) {
fprintf(stderr,"%s:%d: Failed to setup DMA capture with VIDEO1394\n",__FILE__,__LINE__);
goto ERROR;
}
}
else {
if(dc1394_dma_setup_format7_capture(pcap->handle,pcap->camera->node,index+1 /*channel*/,
pcap->mode, SPEED_400, QUERY_FROM_CAMERA,
(unsigned int)QUERY_FROM_CAMERA, (unsigned int)QUERY_FROM_CAMERA,
(unsigned int)QUERY_FROM_CAMERA, (unsigned int)QUERY_FROM_CAMERA,
NUM_BUFFERS,
#ifdef HAVE_DC1394_095
0 /*do_extra_buffering*/,
#endif
1 /*DROP_FRAMES*/,
pcap->device_name, pcap->camera) != DC1394_SUCCESS) {
fprintf(stderr,"%s:%d: Failed to setup DMA capture with VIDEO1394\n",__FILE__,__LINE__);
goto ERROR;
}
}
if (dc1394_start_iso_transmission(pcap->handle, pcap->camera->node)!=DC1394_SUCCESS) {
fprintf(stderr,"%s:%d: Could not start ISO transmission\n",__FILE__,__LINE__);
goto ERROR;
}
usleep(DELAY);
dc1394bool_t status;
if (dc1394_get_iso_status(pcap->handle, pcap->camera->node, &status)!=DC1394_SUCCESS) {
fprintf(stderr,"%s:%d: Could get ISO status",__FILE__,__LINE__);
goto ERROR;
}
if (status==DC1394_FALSE) {
fprintf(stderr,"%s:%d: ISO transmission refuses to start",__FILE__,__LINE__);
goto ERROR;
}
// convert camera image to RGB by default
pcap->convert=1;
// no image data allocated yet
pcap->buffer_is_writeable = 0;
memset(&(pcap->frame), 0, sizeof(IplImage));
icvResizeFrame( pcap );
return (CvCapture *)pcap;
ERROR:
return 0;
};
static int dc1394_read_header(AVFormatContext *c, AVFormatParameters * ap)
{
dc1394_data* dc1394 = c->priv_data;
AVStream* vst;
nodeid_t* camera_nodes;
int res;
struct dc1394_frame_format *fmt;
struct dc1394_frame_rate *fps;
for (fmt = dc1394_frame_formats; fmt->width; fmt++)
if (fmt->pix_fmt == ap->pix_fmt && fmt->width == ap->width && fmt->height == ap->height)
break;
for (fps = dc1394_frame_rates; fps->frame_rate; fps++)
if (fps->frame_rate == av_rescale(1000, ap->time_base.den, ap->time_base.num))
break;
/* create a video stream */
vst = av_new_stream(c, 0);
if (!vst)
return -1;
av_set_pts_info(vst, 64, 1, 1000);
vst->codec->codec_type = CODEC_TYPE_VIDEO;
vst->codec->codec_id = CODEC_ID_RAWVIDEO;
vst->codec->time_base.den = fps->frame_rate;
vst->codec->time_base.num = 1000;
vst->codec->width = fmt->width;
vst->codec->height = fmt->height;
vst->codec->pix_fmt = fmt->pix_fmt;
/* packet init */
av_init_packet(&dc1394->packet);
dc1394->packet.size = avpicture_get_size(fmt->pix_fmt, fmt->width, fmt->height);
dc1394->packet.stream_index = vst->index;
dc1394->packet.flags |= PKT_FLAG_KEY;
dc1394->current_frame = 0;
dc1394->fps = fps->frame_rate;
vst->codec->bit_rate = av_rescale(dc1394->packet.size * 8, fps->frame_rate, 1000);
/* Now lets prep the hardware */
dc1394->handle = dc1394_create_handle(0); /* FIXME: gotta have ap->port */
if (!dc1394->handle) {
av_log(c, AV_LOG_ERROR, "Can't acquire dc1394 handle on port %d\n", 0 /* ap->port */);
goto out;
}
camera_nodes = dc1394_get_camera_nodes(dc1394->handle, &res, 1);
if (!camera_nodes || camera_nodes[ap->channel] == DC1394_NO_CAMERA) {
av_log(c, AV_LOG_ERROR, "There's no IIDC camera on the channel %d\n", ap->channel);
goto out_handle;
}
res = dc1394_dma_setup_capture(dc1394->handle, camera_nodes[ap->channel],
0,
FORMAT_VGA_NONCOMPRESSED,
fmt->frame_size_id,
SPEED_400,
fps->frame_rate_id, 8, 1,
c->filename,
&dc1394->camera);
dc1394_free_camera_nodes(camera_nodes);
if (res != DC1394_SUCCESS) {
av_log(c, AV_LOG_ERROR, "Can't prepare camera for the DMA capture\n");
goto out_handle;
}
res = dc1394_start_iso_transmission(dc1394->handle, dc1394->camera.node);
if (res != DC1394_SUCCESS) {
av_log(c, AV_LOG_ERROR, "Can't start isochronous transmission\n");
goto out_handle_dma;
}
return 0;
out_handle_dma:
dc1394_dma_unlisten(dc1394->handle, &dc1394->camera);
dc1394_dma_release_camera(dc1394->handle, &dc1394->camera);
out_handle:
dc1394_destroy_handle(dc1394->handle);
out:
return -1;
}
int CameraDcam::moduleOn(void)
{
unsigned int uvValue, uuValue;
int ret;
RackTask::disableRealtimeMode();
if (lossRate < 1)
{
GDOS_ERROR("Lossrate must not be less than 1!! EXITING! \n");
return -EINVAL;
}
ret = loadCameraParameter(¶m, intrParFile, lossRate, extrParFile);
if(ret)
{
GDOS_ERROR("Couldn't load camera parameter!! code = %d\n", ret);
return ret;
}
if ( getFirewirePortnum() != DC1394_SUCCESS)
return FW_ERROR;
if ( findCameraByGuid() != DC1394_SUCCESS)
{
GDOS_ERROR("Camera by given guid not found. \n");
return FW_ERROR;
}
GDOS_DBG_INFO("camera_dcam initalising dcam part\n");
/*-----------------------------------------------------------------------
* setup capture format 2 + 7
*-----------------------------------------------------------------------*/
if ( dc1394_get_iso_channel_and_speed( porthandle[dc1394CameraPortNo],
camera_node,
&channel,
&speed) !=DC1394_SUCCESS )
{
GDOS_WARNING("Unable to get the iso channel number\n" );
return FW_ERROR;
}
switch(mode) {
case CAMERA_MODE_YUV422:
case CAMERA_MODE_MONO12:
setupCaptureFormat2();
break;
case CAMERA_MODE_MONO8: //format 2 is possible but no external trigger
case CAMERA_MODE_RAW8:
case CAMERA_MODE_RAW12:
setupCaptureFormat7();
break;
default:
GDOS_ERROR("Set undefined ColorMode.\n" );
return -EINVAL;
}
//need to get max size of image from this camera and also set dataBuffer according
if (CAMERA_MAX_WIDTH < (dc1394Camera.frame_width / lossRate) ||
CAMERA_MAX_HEIGHT < (dc1394Camera.frame_height / lossRate) )
{
GDOS_ERROR("Size parameter set too small in camera.h!! EXITING! \n");
return -ENOMEM;
}
if (param.calibration_width != (int)(dc1394Camera.frame_width / lossRate) ||
param.calibration_height != (int)(dc1394Camera.frame_height / lossRate) )
{
GDOS_ERROR("Size parameter of intrinsic parameter file (%i,%i) and camera (%i,%i) doesn't fit together!!\n",
param.calibration_width, param.calibration_height,
dc1394Camera.frame_width / lossRate, dc1394Camera.frame_height / lossRate);
return -EAGAIN;
}
/*-----------------------------------------------------------------------
* have the camera start sending us data
*-----------------------------------------------------------------------*/
if ( dc1394_start_iso_transmission( porthandle[dc1394CameraPortNo], dc1394Camera.node )
!=DC1394_SUCCESS )
{
GDOS_WARNING("Unable to start camera iso transmission\n" );
return DC1394_FAILURE;
}
GDOS_DBG_INFO("Started iso transmission.\n" );
if (dc1394_get_white_balance(porthandle[dc1394CameraPortNo], camera_node, &uuValue, &uvValue) != DC1394_SUCCESS)
{
GDOS_WARNING("getting of white balance failed! ");
return DC1394_FAILURE;
}
uvValue = vValue;
uuValue = uValue;
if (dc1394_set_white_balance(porthandle[dc1394CameraPortNo], camera_node, uuValue, uvValue) != DC1394_SUCCESS)
{
GDOS_WARNING("setting of white balance failed u:%i v:%i!\n", uuValue, uvValue);
return DC1394_FAILURE;
}
GDOS_DBG_INFO("set u:%i v:%i \n", uuValue, uvValue);
return RackDataModule::moduleOn(); // has to be last command in moduleOn();
}
int
main(int argc, char *argv[])
{
XGCValues xgcv;
long background = 0x010203;
unsigned int channel;
unsigned int speed;
int i, p, cn;
raw1394handle_t raw_handle;
struct raw1394_portinfo ports[MAX_PORTS];
get_options(argc, argv);
/* process options */
switch (fps) {
case 1:
fps = FRAMERATE_1_875;
break;
case 3:
fps = FRAMERATE_3_75;
break;
case 15:
fps = FRAMERATE_15;
break;
case 30:
fps = FRAMERATE_30;
break;
case 60:
fps = FRAMERATE_60;
break;
default:
fps = FRAMERATE_7_5;
break;
}
switch (res) {
case 1:
res = MODE_640x480_YUV411;
device_width = 640;
device_height = 480;
format = XV_YUY2;
break;
case 2:
res = MODE_640x480_RGB;
device_width = 640;
device_height = 480;
format = XV_YUY2;
break;
default:
res = MODE_320x240_YUV422;
device_width = 320;
device_height = 240;
format = XV_UYVY;
break;
}
/* get the number of ports (cards) */
raw_handle = raw1394_new_handle();
if (raw_handle == NULL) {
perror("Unable to aquire a raw1394 handle\n");
perror("did you load the drivers?\n");
exit(-1);
}
numPorts = raw1394_get_port_info(raw_handle, ports, numPorts);
raw1394_destroy_handle(raw_handle);
if (verbose) printf("number of ports = %d\n", numPorts);
/* get dc1394 handle to each port */
for (p = 0; p < numPorts; p++) {
int camCount;
handles[p] = dc1394_create_handle(p);
if (handles[p] == NULL) {
perror("Unable to aquire a raw1394 handle\n");
perror("did you load the drivers?\n");
cleanup();
exit(-1);
}
/* get the camera nodes and describe them as we find them */
camera_nodes = dc1394_get_camera_nodes(handles[p], &camCount, verbose);
/* setup cameras for capture */
for (i = 0; i < camCount; i++) {
cameras[numCameras].node = camera_nodes[i];
if (dc1394_get_camera_feature_set
(handles[p], cameras[numCameras].node,
&features) != DC1394_SUCCESS) {
printf("unable to get feature set\n");
} else if (verbose) {
dc1394_print_feature_set(&features);
}
if (dc1394_get_iso_channel_and_speed
(handles[p], cameras[numCameras].node, &channel,
&speed) != DC1394_SUCCESS) {
printf("unable to get the iso channel number\n");
cleanup();
exit(-1);
}
if (dc1394_dma_setup_capture
(handles[p], cameras[numCameras].node, i + 1 /*channel */ ,
FORMAT_VGA_NONCOMPRESSED, res, SPEED_400, fps, NUM_BUFFERS,
DROP_FRAMES, device_name,
&cameras[numCameras]) != DC1394_SUCCESS) {
fprintf(stderr,
"unable to setup camera - check line %d of %s to make sure\n",
__LINE__, __FILE__);
perror("that the video mode, framerate and format are supported\n");
printf("by your camera(s)\n");
cleanup();
exit(-1);
}
/*have the camera start sending us data */
if (dc1394_start_iso_transmission
(handles[p], cameras[numCameras].node) != DC1394_SUCCESS) {
perror("unable to start camera iso transmission\n");
cleanup();
exit(-1);
}
numCameras++;
}
}
fflush(stdout);
if (numCameras < 1) {
perror("no cameras found :(\n");
cleanup();
exit(-1);
}
//set_manual_exposure_gain(0, 440, 30);
switch (format) {
case XV_YV12:
set_frame_length(device_width * device_height * 3 / 2, numCameras);
break;
case XV_YUY2:
case XV_UYVY:
set_frame_length(device_width * device_height * 2, numCameras);
break;
default:
fprintf(stderr, "Unknown format set (internal error)\n");
exit(255);
}
/* create OpenCV image wrappers */
for (cn = 0; cn < MAX_CAMERAS; cn++) {
if (cn < numCameras) {
iplImages[cn] =
cvCreateImage(cvSize(device_width, device_height),
IPL_DEPTH_8U, 3);
readOnlyImg =
cvCreateImageHeader(cvSize(device_width, device_height),
IPL_DEPTH_8U, 3);
} else {
iplImages[cn] = NULL;
}
}
/* initialize handvu */
hvInitialize(device_width, device_height);
hvLoadConductor(string(conductor_fname));
hvStartRecognition();
hvSetOverlayLevel(3);
if (async_processing) {
hvAsyncSetup(num_async_bufs, displayCallback);
hvAsyncGetImageBuffer(&m_async_image, &m_async_bufID);
if (sync_display) async_display_image = cvCloneImage(iplImages[0]);
}
/* make the window */
display = XOpenDisplay(getenv("DISPLAY"));
if (display == NULL) {
fprintf(stderr, "Could not open display \"%s\"\n", getenv("DISPLAY"));
cleanup();
exit(-1);
}
QueryXv();
if (adaptor < 0) {
cleanup();
exit(-1);
}
width = device_width;
height = device_height * numCameras;
window =
XCreateSimpleWindow(display, DefaultRootWindow(display), 0, 0,
width, height, 0, WhitePixel(display,
DefaultScreen
(display)), background);
XSelectInput(display, window, StructureNotifyMask | KeyPressMask);
XMapWindow(display, window);
connection = ConnectionNumber(display);
gc = XCreateGC(display, window, 0, &xgcv);
/* local main event loop */
while (1) {
if (async_processing) {
// asynchronous processing in HandVu
capture_frame();
process_frame();
if (sync_display) display_frame();
handle_events();
} else {
// synchronous processing in HandVu
capture_frame();
process_frame();
display_frame();
handle_events();
}
/* XPending */
} /* while not interrupted */
exit(0);
}
/*****************************************************************************
* Open:
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
demux_t *p_demux = (demux_t*)p_this;
demux_sys_t *p_sys;
es_format_t fmt;
int i;
int i_width;
int i_height;
int result = 0;
if( strncmp(p_demux->psz_access, "dc1394", 6) != 0 )
return VLC_EGENERIC;
/* Set up p_demux */
p_demux->pf_demux = Demux;
p_demux->pf_control = Control;
p_demux->info.i_update = 0;
p_demux->info.i_title = 0;
p_demux->info.i_seekpoint = 0;
p_demux->p_sys = p_sys = calloc( 1, sizeof( demux_sys_t ) );
if( !p_sys )
return VLC_ENOMEM;
memset( &fmt, 0, sizeof( es_format_t ) );
/* DEFAULTS */
p_sys->frame_size = MODE_640x480_YUV422;
p_sys->width = 640;
p_sys->height = 480;
p_sys->frame_rate = FRAMERATE_30;
p_sys->brightness = 200;
p_sys->focus = 0;
p_sys->dma_capture = DMA_ON; /* defaults to VIDEO1394 capture mode */
p_sys->fd_audio = -1;
p_sys->fd_video = NULL;
p_sys->camera_nodes = NULL;
p_sys->selected_camera = 0;
p_sys->dma_device = NULL;
p_sys->selected_uid = 0;
/* PROCESS INPUT OPTIONS */
if( process_options(p_demux) != VLC_SUCCESS )
{
msg_Err( p_demux, "Bad MRL, please check the option line "
"(MRL was: %s)",
p_demux->psz_path );
free( p_sys );
p_demux->p_sys = NULL;
return VLC_EGENERIC;
}
msg_Dbg( p_demux, "Selected camera %d", p_sys->selected_camera );
msg_Dbg( p_demux, "Selected uid 0x%llx", p_sys->selected_uid );
ScanCameras( p_sys, p_demux );
if( !p_sys->camera_nodes )
{
msg_Err( p_demux, "No camera found !!" );
free( p_sys );
p_demux->p_sys = NULL;
return VLC_EGENERIC;
}
if( p_sys->selected_uid )
{
int found = 0;
for( i=0; i < p_sys->num_cameras; i++ )
{
if( p_sys->camera_nodes[i].uid == p_sys->selected_uid )
{
p_sys->selected_camera = i;
found++;
break;
}
}
if( !found )
{
msg_Err( p_demux, "Can't find camera with uid : 0x%llx.",
p_sys->selected_uid );
Close( p_this );
return VLC_EGENERIC;
}
}
else if( p_sys->selected_camera >= p_sys->num_cameras )
{
msg_Err( p_demux, "there are not this many cameras. (%d/%d)",
p_sys->selected_camera, p_sys->num_cameras );
Close( p_this );
return VLC_EGENERIC;
}
p_sys->fd_video = dc1394_create_handle(
p_sys->camera_nodes[p_sys->selected_camera].port );
if( (int)p_sys->fd_video < 0 )
{
msg_Err( p_demux, "Can't init dc1394 handle" );
Close( p_this );
return VLC_EGENERIC;
}
/* get camera info */
result = dc1394_get_camera_info( p_sys->fd_video,
p_sys->camera_nodes[p_sys->selected_camera].node,
&p_sys->camera_info );
if( result != DC1394_SUCCESS )
{
msg_Err( p_demux ,"unable to get camera info" );
Close( p_this );
return VLC_EGENERIC;
}
dc1394_print_camera_info( &p_sys->camera_info );
result = dc1394_get_camera_misc_info( p_sys->fd_video,
p_sys->camera_nodes[p_sys->selected_camera].node,
&p_sys->misc_info );
if( result != DC1394_SUCCESS )
{
msg_Err( p_demux, "unable to get camera misc info" );
Close( p_this );
return VLC_EGENERIC;
}
/* init camera and set some video options */
result = dc1394_init_camera( p_sys->camera_info.handle,
p_sys->camera_info.id );
if( result != DC1394_SUCCESS )
{
msg_Err( p_demux, "unable to get init dc1394 camera" );
Close( p_this );
return VLC_EGENERIC;
}
if( p_sys->focus )
{
result = dc1394_set_focus( p_sys->camera_info.handle,
p_sys->camera_nodes[p_sys->selected_camera].node,
p_sys->focus );
if( result != DC1394_SUCCESS )
{
msg_Err( p_demux, "unable to set initial focus to %u",
p_sys->focus );
}
msg_Dbg( p_demux, "Initial focus set to %u", p_sys->focus );
}
result = dc1394_set_brightness( p_sys->camera_info.handle,
p_sys->camera_nodes[p_sys->selected_camera].node,
p_sys->brightness );
if( result != DC1394_SUCCESS )
{
msg_Err( p_demux, "unable to set init brightness to %d",
p_sys->brightness);
Close( p_this );
return VLC_EGENERIC;
}
result = dc1394_set_video_framerate( p_sys->camera_info.handle,
p_sys->camera_nodes[p_sys->selected_camera].node,
p_sys->frame_rate );
if( result != DC1394_SUCCESS )
{
msg_Err( p_demux, "unable to set framerate to %d",
p_sys->frame_rate );
Close( p_this );
return VLC_EGENERIC;
}
p_sys->misc_info.framerate = p_sys->frame_rate;
result = dc1394_set_video_format( p_sys->camera_info.handle,
p_sys->camera_nodes[p_sys->selected_camera].node,
FORMAT_VGA_NONCOMPRESSED );
if( result != DC1394_SUCCESS )
{
msg_Err( p_demux, "unable to set video format to VGA_NONCOMPRESSED" );
Close( p_this );
return VLC_EGENERIC;
}
p_sys->misc_info.format = FORMAT_VGA_NONCOMPRESSED;
result = dc1394_set_video_mode( p_sys->camera_info.handle,
p_sys->camera_nodes[p_sys->selected_camera].node,
p_sys->frame_size );
if( result != DC1394_SUCCESS )
{
msg_Err( p_demux, "unable to set video mode" );
Close( p_this );
return VLC_EGENERIC;
}
p_sys->misc_info.mode = p_sys->frame_size;
/* reprobe everything */
result = dc1394_get_camera_info( p_sys->camera_info.handle,
p_sys->camera_info.id,
&p_sys->camera_info );
if( result != DC1394_SUCCESS )
{
msg_Err( p_demux, "Could not get camera basic information!" );
Close( p_this );
return VLC_EGENERIC;
}
result = dc1394_get_camera_misc_info( p_sys->camera_info.handle,
p_sys->camera_info.id,
&p_sys->misc_info );
if( result != DC1394_SUCCESS )
{
msg_Err( p_demux, "Could not get camera misc information!" );
Close( p_this );
return VLC_EGENERIC;
}
/* set iso_channel */
result = dc1394_set_iso_channel_and_speed( p_sys->camera_info.handle,
p_sys->camera_info.id,
p_sys->selected_camera,
SPEED_400 );
if( result != DC1394_SUCCESS )
{
msg_Err( p_demux, "Could not set iso channel!" );
Close( p_this );
return VLC_EGENERIC;
}
msg_Dbg( p_demux, "Using ISO channel %d", p_sys->misc_info.iso_channel );
p_sys->misc_info.iso_channel = p_sys->selected_camera;
/* and setup capture */
if( p_sys->dma_capture )
{
result = dc1394_dma_setup_capture( p_sys->camera_info.handle,
p_sys->camera_info.id,
p_sys->misc_info.iso_channel,
p_sys->misc_info.format,
p_sys->misc_info.mode,
SPEED_400,
p_sys->misc_info.framerate,
10, 0,
p_sys->dma_device,
&p_sys->camera );
if( result != DC1394_SUCCESS )
{
msg_Err( p_demux ,"unable to setup camera" );
Close( p_this );
return VLC_EGENERIC;
}
}
else
{
result = dc1394_setup_capture( p_sys->camera_info.handle,
p_sys->camera_info.id,
p_sys->misc_info.iso_channel,
p_sys->misc_info.format,
p_sys->misc_info.mode,
SPEED_400,
p_sys->misc_info.framerate,
&p_sys->camera );
if( result != DC1394_SUCCESS)
{
msg_Err( p_demux ,"unable to setup camera" );
Close( p_this );
return VLC_EGENERIC;
}
}
/* TODO - UYV444 chroma converter is missing, when it will be available
* fourcc will become variable (and not just a fixed value for UYVY)
*/
i_width = p_sys->camera.frame_width;
i_height = p_sys->camera.frame_height;
if( picture_Setup( &p_sys->pic, VLC_CODEC_UYVY,
i_width, i_height,
i_width * VOUT_ASPECT_FACTOR / i_height ) )
{
msg_Err( p_demux ,"unknown chroma" );
Close( p_this );
return VLC_EGENERIC;
}
es_format_Init( &fmt, VIDEO_ES, VLC_CODEC_UYVY );
fmt.video.i_width = i_width;
fmt.video.i_height = i_height;
msg_Dbg( p_demux, "added new video es %4.4s %dx%d",
(char*)&fmt.i_codec, fmt.video.i_width, fmt.video.i_height );
p_sys->p_es_video = es_out_Add( p_demux->out, &fmt );
if( p_sys->audio_device )
{
OpenAudioDev( p_demux );
if( p_sys->fd_audio >= 0 )
{
es_format_t fmt;
es_format_Init( &fmt, AUDIO_ES, VLC_CODEC_S16L ); /* FIXME: hmm, ?? */
fmt.audio.i_channels = p_sys->channels ? p_sys->channels : 1;
fmt.audio.i_rate = p_sys->i_sample_rate;
fmt.audio.i_bitspersample = 16;
fmt.audio.i_blockalign = fmt.audio.i_channels *
fmt.audio.i_bitspersample / 8;
fmt.i_bitrate = fmt.audio.i_channels * fmt.audio.i_rate *
fmt.audio.i_bitspersample;
msg_Dbg( p_demux, "new audio es %d channels %dHz",
fmt.audio.i_channels, fmt.audio.i_rate );
p_sys->p_es_audio = es_out_Add( p_demux->out, &fmt );
}
}
/* have the camera start sending us data */
result = dc1394_start_iso_transmission( p_sys->camera_info.handle,
p_sys->camera_info.id );
if( result != DC1394_SUCCESS )
{
msg_Err( p_demux, "unable to start camera iso transmission" );
if( p_sys->dma_capture )
{
dc1394_dma_release_camera( p_sys->fd_video, &p_sys->camera );
}
else
{
dc1394_release_camera( p_sys->fd_video, &p_sys->camera );
}
Close( p_this );
return VLC_EGENERIC;
}
p_sys->misc_info.is_iso_on = DC1394_TRUE;
return VLC_SUCCESS;
}
int dc1394Init(int cam, int width, int height, int max_frames, int trigger_mode, int shutter, int gain, int trig_on, int iso_speed, int frame_rate)
{
int numNodes;
nodeid_t * camera_nodes;
int numCameras;
if (first) {
bzero(Cams, sizeof(Cams));
first = 0;
}
printf("now is the time\n");
if ((cam < 0) || (cam >= MAX_CAMERAS)) {
fprintf(stderr, "Camera out of range, cam = %d must be between 0 and %d\n", cam, MAX_CAMERAS);
return 0;
}
/* clean up any active daq */
if (Cams[cam].thread_id != 0) {
void *status;
pthread_cancel(Cams[cam].thread_id);
pthread_join(Cams[cam].thread_id, &status);
Cams[cam].thread_id = 0;
}
/* now find the camera choke if not there or not correct */
Cams[cam].handle = dc1394_create_handle(0);
if (Cams[cam].handle==NULL)
{
fprintf( stderr, "Unable to aquire a raw1394 handle\n\n"
"Please check \n"
" - if the kernel modules `ieee1394',`raw1394' and `ohci1394' are loaded \n"
" - if you have read/write access to /dev/raw1394\n\n");
return(0);
}
/*-----------------------------------------------------------------------
* get the camera nodes and describe them as we find them
*-----------------------------------------------------------------------*/
numNodes = raw1394_get_nodecount(Cams[cam].handle);
camera_nodes = dc1394_get_camera_nodes(Cams[cam].handle,&numCameras,1);
if (numCameras<1)
{
fprintf( stderr, "no cameras found :(\n");
dc1394_destroy_handle(Cams[cam].handle);
Cams[cam].handle = 0;
return(0);
}
/*-----------------------------------------------------------------------
* to prevent the iso-transfer bug from raw1394 system, check if
* camera is highest node. For details see
* http://linux1394.sourceforge.net/faq.html#DCbusmgmt
* and
* http://sourceforge.net/tracker/index.php?func=detail&aid=435107&group_id=8157&atid=108157
*-----------------------------------------------------------------------*/
if( camera_nodes[0] == numNodes-1)
{
fprintf( stderr, "\n"
"Sorry, your camera is the highest numbered node\n"
"of the bus, and has therefore become the root node.\n"
"The root node is responsible for maintaining \n"
"the timing of isochronous transactions on the IEEE \n"
"1394 bus. However, if the root node is not cycle master \n"
"capable (it doesn't have to be), then isochronous \n"
"transactions will not work. The host controller card is \n"
"cycle master capable, however, most cameras are not.\n"
"\n"
"The quick solution is to add the parameter \n"
"attempt_root=1 when loading the OHCI driver as a \n"
"module. So please do (as root):\n"
"\n"
" rmmod ohci1394\n"
" insmod ohci1394 attempt_root=1\n"
"\n"
"for more information see the FAQ at \n"
"http://linux1394.sourceforge.net/faq.html#DCbusmgmt\n"
"\n");
dc1394_destroy_handle(Cams[cam].handle);
dc1394_free_camera_nodes(camera_nodes);
return(0);
}
/*-----------------------------------------------------------------------
* setup capture
*-----------------------------------------------------------------------*/
if (dc1394_dma_setup_capture(Cams[cam].handle,camera_nodes[0],
0, /* channel */
FORMAT_VGA_NONCOMPRESSED,
MODE_640x480_MONO,
SPEED_400,
FRAMERATE_30,
3, /* frames */
1,
"/dev/video1394/0",
&Cams[cam].camera)!=DC1394_SUCCESS)
{
fprintf( stderr,"unable to setup camera-\n"
"check line %d of %s to make sure\n"
"that the video mode,framerate and format are\n"
"supported by your camera\n",
__LINE__,__FILE__);
dc1394_dma_release_camera(Cams[cam].handle,&Cams[cam].camera);
Cams[cam].dma_active = 0;
dc1394_destroy_handle(Cams[cam].handle);
Cams[cam].handle = 0;
dc1394_free_camera_nodes(camera_nodes);
return(0);
}
dc1394_free_camera_nodes(camera_nodes);
/* set trigger mode */
if( dc1394_set_trigger_mode(Cams[cam].handle, Cams[cam].camera.node, trigger_mode)
!= DC1394_SUCCESS)
{
fprintf( stderr, "unable to set camera trigger mode\n");
/*
dc1394_dma_release_camera(Cams[cam].handle,&Cams[cam].camera);
Cams[cam].dma_active = 0;
dc1394_destroy_handle(Cams[cam].handle);
Cams[cam].handle = 0;
return(0);
*/
}
/* eventually the same for the shutter and gain */
if (dc1394_set_trigger_on_off(Cams[cam].handle, Cams[cam].camera.node,
trig_on) != DC1394_SUCCESS)
{
fprintf(stderr, "unable to set trigger on to %d\n", trig_on);
}
/*-----------------------------------------------------------------------
* have the camera start sending us data
*-----------------------------------------------------------------------*/
if (dc1394_start_iso_transmission(Cams[cam].handle,Cams[cam].camera.node) !=DC1394_SUCCESS)
{
fprintf( stderr, "unable to start camera iso transmission\n");
dc1394_dma_release_camera(Cams[cam].handle,&Cams[cam].camera);
Cams[cam].dma_active = 0;
dc1394_destroy_handle(Cams[cam].handle);
Cams[cam].handle = 0;
return(0);
}
Cams[cam].running = 1;
/* make room for the answers and write down all of the knobs for later use */
if ( (width != Cams[cam].width) ||
(height != Cams[cam].height) ||
(max_frames != Cams[cam].max_frames) ){
if (Cams[cam].frames != NULL)
free(Cams[cam].frames);
Cams[cam].frames = (unsigned char *)malloc(width*height*max_frames);
if (Cams[cam].frames == NULL) {
fprintf(stderr, "Could not allocate memory for %d frames (%d x %d)\n", max_frames, width, height);
dc1394_dma_release_camera(Cams[cam].handle,&Cams[cam].camera);
Cams[cam].dma_active = 0;
dc1394_destroy_handle(Cams[cam].handle);
Cams[cam].handle = 0;
Cams[cam].max_frames = 0;
return(0);
}
Cams[cam].times = (double *)malloc(max_frames * sizeof(double));
if (Cams[cam].times == NULL) {
fprintf(stderr, "Could not allocate memory for %d times\n", max_frames);
dc1394_dma_release_camera(Cams[cam].handle,&Cams[cam].camera);
free( Cams[cam].frames );
Cams[cam].dma_active = 0;
dc1394_destroy_handle(Cams[cam].handle);
Cams[cam].handle = 0;
Cams[cam].max_frames = 0;
return(0);
}
Cams[cam].width = width;
Cams[cam].height = height;
Cams[cam].max_frames = max_frames;
}
Cams[cam].next_frame = 0;
Cams[cam].trigger_mode = trigger_mode;
Cams[cam].shutter = shutter;
Cams[cam].gain = gain;
if (pthread_create(&Cams[cam].thread_id, NULL, AcquireFrames, (void *)cam) != 0) {
fprintf(stderr, "Could not create thread to handle camera daq\n");
dc1394_stop_iso_transmission(Cams[cam].handle,Cams[cam].camera.node);
Cams[cam].running = 0;
dc1394_dma_release_camera(Cams[cam].handle,&Cams[cam].camera);
Cams[cam].dma_active = 0;
dc1394_destroy_handle(Cams[cam].handle);
Cams[cam].handle = 0;
return(0);
}
return(1);
}
