/*****************************************************************************
* Close:
*****************************************************************************/
static void Close( vlc_object_t *p_this )
{
demux_t *p_demux = (demux_t*)p_this;
demux_sys_t *p_sys = p_demux->p_sys;
int result = 0;
/* Stop data transmission */
result = dc1394_stop_iso_transmission( p_sys->fd_video,
p_sys->camera.node );
if( result != DC1394_SUCCESS )
{
msg_Err( p_demux, "couldn't stop the camera" );
}
/* Close camera */
if( p_sys->dma_capture )
{
dc1394_dma_unlisten( p_sys->fd_video, &p_sys->camera );
dc1394_dma_release_camera( p_sys->fd_video, &p_sys->camera );
}
else
{
dc1394_release_camera( p_sys->fd_video, &p_sys->camera );
}
if( p_sys->fd_video )
dc1394_destroy_handle( p_sys->fd_video );
CloseAudioDev( p_demux );
free( p_sys->camera_nodes );
free( p_sys->audio_device );
free( p_sys );
}
void dc1394_close(void)
{
fprintf( stderr, "closing down..." );
dc1394_dma_unlisten( handle, &camera );
dc1394_dma_release_camera( handle, &camera );
dc1394_destroy_handle( handle );
fprintf( stderr, "done!\n" );
}
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_close(AVFormatContext * context)
{
struct dc1394_data *dc1394 = context->priv_data;
dc1394_stop_iso_transmission(dc1394->handle, dc1394->camera.node);
dc1394_dma_unlisten(dc1394->handle, &dc1394->camera);
dc1394_dma_release_camera(dc1394->handle, &dc1394->camera);
dc1394_destroy_handle(dc1394->handle);
return 0;
}
static void *AcquireFrames(void *arg) {
struct timeval tv;
int start_sec;
int cam = (int)arg;
pthread_cleanup_push(dc1394Done, (void *)cam);
printf("in acquire\n");
gettimeofday(&tv, NULL);
start_sec = tv.tv_sec;
printf("start sec is %d\n", start_sec);
for (Cams[cam].next_frame=0; Cams[cam].next_frame < Cams[cam].max_frames; Cams[cam].next_frame++) {
if (dc1394_dma_single_capture(&Cams[cam].camera)!=DC1394_SUCCESS) {
fprintf( stderr, "unable to capture a frame\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;
Cams[cam].thread_id =0;
return;
}
gettimeofday(&tv, NULL);
Cams[cam].times[Cams[cam].next_frame] = tv.tv_sec-start_sec+(double)tv.tv_usec*1E-6;
printf("The time for frame %d is %g\n", Cams[cam].next_frame, Cams[cam].times[Cams[cam].next_frame]);
memcpy((void *)Cams[cam].frames+Cams[cam].next_frame*Cams[cam].width*Cams[cam].height, Cams[cam].camera.capture_buffer, Cams[cam].width*Cams[cam].height);
dc1394_dma_done_with_buffer(&Cams[cam].camera);
printf("got frame %d\n", Cams[cam].next_frame);
}
/* clean up active daq */
dc1394_stop_iso_transmission(Cams[cam].handle,Cams[cam].camera.node);
Cams[cam].running = 0;
dc1394_dma_unlisten(Cams[cam].handle, &Cams[cam].camera);
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].thread_id =0;
pthread_cleanup_pop(0);
return;
}
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;
}
bool linuxfwCamera::closeCamera() {
if (use_dma) {
dc1394_dma_unlisten(handle, &camera);
dc1394_dma_release_camera(handle, &camera);
}
else {
dc1394_release_camera(handle,&camera);
}
dc1394_camera_off(handle, cameraID);
dc1394_destroy_handle(handle);
return true;
}
static void icvCloseCAM_DC1394( CvCaptureCAM_DC1394* capture ){
_V_MW_ fprintf(stderr, "icvCloseCAM_DC1394\n");
dc1394_stop_iso_transmission(capture->handle, capture->camera->node);
dc1394_dma_release_camera(capture->handle, capture->camera); // MW !!!
/* Deallocate space for RGBA data */
if(capture->convert){
cvFree(&capture->frame.imageData);
}
}
//---------------------------------------------------------------
void
Device1394::fini()
{
MIRO_DBG(VIDEO, LL_DEBUG, "Device1394::fini()");
if (is_open_)
{
MIRO_DBG(VIDEO, LL_DEBUG, "Device1394::fini() close");
dc1394_stop_iso_transmission(handle_, p_camera_->node);
dc1394_dma_unlisten(handle_, p_camera_);
dc1394_dma_release_camera(handle_, p_camera_);
is_open_ = false;
}
cleanupDevice();
}
void CameraDcam::moduleOff(void)
{
RackDataModule::moduleOff(); // has to be first command in moduleOff();
if ( dc1394_stop_iso_transmission( porthandle[dc1394CameraPortNo],dc1394Camera.node ) != DC1394_SUCCESS )
{
GDOS_WARNING("Couldn't stop the iso transmission!!\n");
}
if ( dc1394_dma_unlisten( porthandle[dc1394CameraPortNo], &dc1394Camera ) != DC1394_SUCCESS)
{
GDOS_WARNING("Couldn't unlisten the dma!!\n");
}
if( dc1394_dma_release_camera( porthandle[dc1394CameraPortNo], &dc1394Camera ) != DC1394_SUCCESS)
{
GDOS_WARNING("Couldn't release the dma!!\n");
}
}
void dc1394Done(void *arg) {
int cam = (int)arg;
printf("here I am in done - %d %d\n", cam, Cams[cam].running);
/* clean up any active daq */
if (Cams[cam].running) {
printf("stop the dma\n\n");
dc1394_dma_unlisten(Cams[cam].handle, &Cams[cam].camera);
dc1394_stop_iso_transmission(Cams[cam].handle,Cams[cam].camera.node);
Cams[cam].running = 0;
}
if (Cams[cam].dma_active) {
dc1394_dma_release_camera(Cams[cam].handle,&Cams[cam].camera);
Cams[cam].dma_active = 0;
}
if (Cams[cam].handle != NULL) {
dc1394_destroy_handle(Cams[cam].handle);
Cams[cam].handle = 0;
}
printf("all done with Don\n");
}
void
cleanup(void)
{
int i;
for (i = 0; i < numCameras; i++) {
dc1394_dma_unlisten(handles[cameras[i].port], &cameras[i]);
dc1394_dma_release_camera(handles[cameras[i].port], &cameras[i]);
}
for (i = 0; i < numPorts; i++)
raw1394_destroy_handle(handles[i]);
if ((void *) window != NULL)
XUnmapWindow(display, window);
if (display != NULL)
XFlush(display);
if (frame_buffer != NULL)
free(frame_buffer);
// OpenCV cleanup
for (i = 0; i < numCameras; i++) {
cvReleaseImageHeader(&iplImages[i]);
}
}
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;
}
unsigned char* linuxfwCamera::getFrame() {
if (handle==NULL) return NULL;
if (use_dma) {
if (dc1394_dma_single_capture(&camera)!=DC1394_SUCCESS)
{
fprintf( stderr, "unable to capture a frame\n");
dc1394_dma_release_camera(handle,&camera);
dc1394_destroy_handle(handle);
return NULL;
} dc1394_dma_done_with_buffer(&camera);
} else {
if (dc1394_single_capture(handle,&camera)!=DC1394_SUCCESS)
{
fprintf( stderr, "unable to capture a frame\n");
dc1394_dma_release_camera(handle,&camera);
dc1394_destroy_handle(handle);
return NULL;
}
}
switch (colour) {
case false: {
if (image_mode_==MODE_640x480_YUV411) {
unsigned char *src = (unsigned char*)camera.capture_buffer;
unsigned char *dest = buffer;
for(int y=0;y<height;y++) {
for(int x=0;x<width/4;++x) {
src++;
*dest++ = *src++;
*dest++ = *src++;
src++;
*dest++ = *src++;
*dest++ = *src++;
}
}
} else {
if (buffer!=NULL)
memcpy(buffer,(unsigned char*)camera.capture_buffer,width*height*bytes);
}
break;
}
case true: {
if (image_mode_==MODE_640x480_YUV411) {
int R,G,B;
int Y[4];
int U,V;
unsigned char *src = (unsigned char*)camera.capture_buffer;
unsigned char *dest = buffer;
for(int y=0;y<height;y++) {
for(int x=0;x<width/4;++x) {
U = *src++;
Y[0] = *src++;
Y[1] = *src++;
V = *src++;
Y[2] = *src++;
Y[3] = *src++;
// U and V are +-0.5
U -= 128;
V -= 128;
// conversion
for (int i=0;i<4;i++) {
R = (int)(Y[i] + 1.370705f * V); //R
G = (int)(Y[i] - 0.698001f * V - 0.337633f * U); //G
B = (int)(Y[i] + 1.732446f * U); //B
if (R < 0) R=0;
if (G < 0) G=0;
if (B < 0) B=0;
if (R > 255) R=255;
if (G > 255) G=255;
if (B > 255) B=255;
*dest++ = B;
*dest++ = G;
*dest++ = R;
}
}
}
} else {
if (buffer!=NULL)
memcpy(buffer,(unsigned char*)camera.capture_buffer,width*height*bytes);
}
break;
}
}
return buffer;
}
/*****************************************************************************
* 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);
}
