//---------------------------------------------------------------
void
Device1394::initDevice(int port)
{
MIRO_DBG(VIDEO, LL_DEBUG, "Device1394::initDevice()");
handle_ = dc1394_create_handle(port);
if (!handle_) {
throw Miro::Exception("Device1394::initDevice: unable to create handle");
}
int num_nodes = raw1394_get_nodecount(handle_);
int camera_count = 0;
nodeid_t * camera_nodes = dc1394_get_camera_nodes(handle_, &camera_count, 1);
MIRO_DBG_OSTR(VIDEO, LL_DEBUG,
"Device1394::initDevice: cameracount = " << camera_count);
if (camera_count < 1)
throw Miro::Exception("Device1394::initDevice: no camera found");
p_camera_->node = camera_nodes[0];
MIRO_DBG_OSTR(VIDEO, LL_DEBUG,
"Device1394::initDevice: node = " <<
p_camera_->node << "/" << num_nodes);
if (p_camera_->node == num_nodes - 1)
throw Miro::Exception("Device1394::initDevice: camera is highest numbered node.");
dc1394_stop_iso_transmission(handle_, p_camera_->node);
if (dc1394_get_camera_feature_set(handle_, p_camera_->node, &features_) != DC1394_SUCCESS)
throw Miro::Exception("Device1394::initDevice: unable to get camera features");
if (Miro::Log::level() >= Miro::Log::LL_NOTICE)
dc1394_print_feature_set(&features_);
}
void icvInitCapture_DC1394(){
int p;
_V_MW_ fprintf(stderr,"icvInitCapture_DC1394\n");
raw1394handle_t raw_handle = raw1394_new_handle();
if( raw_handle == 0 ) {
numPorts = 0;
return;
}
numPorts = raw1394_get_port_info(raw_handle, ports, MAX_PORTS);
raw1394_destroy_handle(raw_handle);
for (p = 0; p < numPorts; p++) {
handles[p] = dc1394_create_handle(p);
if (handles[p]==NULL) { numPorts=-1; return; /*ERROR_CLEANUP_EXIT*/ }
/* get the camera nodes and describe them as we find them */
camera_nodes = dc1394_get_camera_nodes(handles[p], &camCount[p], 0);
for (int i=0;i<camCount[p];i++) {
cameras[numCameras].cam.node = camera_nodes[i];
cameras[numCameras].portnum = p;
dc1394_stop_iso_transmission(handles[p], camera_nodes[i]);
numCameras++;
}
}
};
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;
}
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;
}
bool linuxfwCamera::findCamera() {
// get the number of ports
raw1394handle_t phandle = raw1394_new_handle();
if (phandle==NULL) {
printf( "no firewire ports found\n");
return false;
}
struct raw1394_portinfo pinf;
int ports = raw1394_get_port_info(phandle, &pinf, 0);
dc1394_destroy_handle(phandle);
//printf("firewire ports: %d\n",ports);
if (ports<1) {
printf("no firewire ports found\n");
return false;
}
// open ohci and asign handle to it
for (int i=0;i<ports;i++) {
//printf("trying port %d\n",i);
handle = dc1394_create_handle(i);
// get the camera nodes and describe them as we find them
numNodes = raw1394_get_nodecount(handle);
camera_nodes = dc1394_get_camera_nodes(handle,&numCameras,0);
//fflush(stdout);
//printf("found %d cameras\n",numCameras);
if (numCameras<1) {
dc1394_destroy_handle(handle);
continue;
} else {
cameraID = 0;
return true;
}
}
fprintf( stderr, "no firewire camera found\n");
return false;
}
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::findCameraByGuid(void)
{
/*-----------------------------------------------------------------------
* get the camera nodes and describe them as we find them
* Number of available ports is known globally.
*-----------------------------------------------------------------------*/
//as the root node is not determined statically we may reset the bus in order to make a camera become
//NOT a root node.
//Uses generally the first camera found on bus.
int portNum,resetNum, numNodes, foundCamerasOnBus;
int resetBus = 1;
nodeid_t * camera_nodes = NULL;
for (resetNum=0; resetNum < MAX_RESETS && resetBus == 1; resetNum++)
{
resetBus = 0;
foundCamerasOnBus = 0;
for (portNum=0; portNum < firewireNumPorts; portNum++)
{
porthandle[portNum] = dc1394_create_handle(portNum);//handle for portNum
if (porthandle[portNum]==NULL)
{
GDOS_WARNING("error: Unable to aquire handle for port %i.\n", portNum);
}
//each port can have multiple cameras attached.
numNodes = 0;
camera_nodes = dc1394_get_camera_nodes(porthandle[portNum], &numNodes, 0); //last parameter defines if output is given.
//if any camera is found on this port...
if (numNodes > 0)
{
GDOS_DBG_INFO("found %i cameras to port %i.\n",numNodes, portNum);
//try to put them all at their position.
int k;
for (k = 0; k < numNodes; k++)
{
//try to get camera guid
dc1394_camerainfo info;
if (dc1394_get_camera_info(porthandle[portNum], camera_nodes[k], &info) == DC1394_SUCCESS)
{
//test if camera node is root, if so reset bus...
if (camera_nodes[k] == raw1394_get_nodecount(porthandle[portNum])-1)
{
//reset and retry if root
GDOS_WARNING("error: camera found as root node - resetting.\n");
raw1394_reset_bus(porthandle[portNum]);
int node_pos = 0;
for (node_pos=0; node_pos < 10; node_pos++)
resetBus = 1;
foundCamerasOnBus = foundCamerasOnBus - k; //no -1 as the array stqarts with 0
}
GDOS_DBG_INFO("found camera with guid:%x \n", info.euid_64);
//put camera in the global variable
if ((cameraGuid == 0) || (cameraGuid == (int) info.euid_64))
{
GDOS_DBG_INFO("using camera node:%i with guid:%x \n",camera_nodes[k], info.euid_64);
camera_node = camera_nodes[k];
dc1394CameraPortNo = portNum;
}
foundCamerasOnBus = foundCamerasOnBus + 1;
}//if camera_info
}//for numCameras
}//if numCamera > 0
else {
GDOS_ERROR("No cameras found! (%d nodes on the bus)\n"
" - could be you need to try a different 1394 device (modify code to fix)\n",
numNodes );
}
}//for firewireNumPorts
}//for MAXRESETS
GDOS_DBG_INFO("bus init complete found %i cameras.\n",foundCamerasOnBus);
if (resetNum == MAX_RESETS-1)
return FW_ERROR;
return DC1394_SUCCESS;
}
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;
}
/*****************************************************************************
* ScanCameras
*****************************************************************************/
static void ScanCameras( dc1394_sys *sys, demux_t *p_demux )
{
struct raw1394_portinfo portinfo[MAX_IEEE1394_HOSTS];
raw1394handle_t tempFd;
dc1394_camerainfo info;
dc_camera *node_list = NULL;
nodeid_t *nodes = NULL;
int num_ports = 0;
int num_cameras = 0;
int nodecount;
int i, n;
memset( &portinfo, 0, sizeof(portinfo) );
msg_Dbg( p_demux, "Scanning for ieee1394 ports ..." );
tempFd = raw1394_new_handle();
if( !tempFd )
return VLC_EGENERIC;
raw1394_get_port_info( tempFd, portinfo, MAX_IEEE1394_HOSTS);
raw1394_destroy_handle( tempFd );
for( i=0; i < MAX_IEEE1394_HOSTS; i++ )
{
/* check if port exists and has at least one node*/
if( !portinfo[i].nodes )
continue;
nodes = NULL;
nodecount = 0;
tempFd = dc1394_create_handle( i );
/* skip this port if we can't obtain a valid handle */
if( !tempFd )
continue;
msg_Dbg( p_demux, "Found ieee1394 port %d (%s) ... "
"checking for camera nodes",
i, portinfo[i].name );
num_ports++;
nodes = dc1394_get_camera_nodes( tempFd, &nodecount, 0 );
if( nodecount )
{
msg_Dbg( p_demux, "Found %d dc1394 cameras on port %d (%s)",
nodecount, i, portinfo[i].name );
if( node_list )
node_list = realloc( node_list, sizeof(dc_camera) * (num_cameras+nodecount) );
else
node_list = malloc( sizeof(dc_camera) * nodecount);
for( n = 0; n < nodecount; n++ )
{
int result = 0;
result = dc1394_get_camera_info( tempFd, nodes[n], &info );
if( result == DC1394_SUCCESS )
{
node_list[num_cameras+n].uid = info.euid_64;
}
node_list[num_cameras+n].node = nodes[n];
node_list[num_cameras+n].port = i;
}
num_cameras += nodecount;
}
else
msg_Dbg( p_demux, "no cameras found on port %d (%s)",
i, portinfo[i].name );
if( tempFd )
dc1394_destroy_handle( tempFd );
}
sys->num_ports = num_ports;
sys->num_cameras = num_cameras;
sys->camera_nodes = node_list;
}
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);
}
