gboolean
gst_dc1394_change_camera_transmission (GstDc1394 * src, gboolean on)
{
dc1394switch_t status = DC1394_OFF;
dc1394error_t err = DC1394_FAILURE;
gint i = 0;
g_return_val_if_fail (src->camera, FALSE);
if (on) {
status = dc1394_video_set_transmission (src->camera, DC1394_ON);
i = 0;
while (status == DC1394_OFF && i++ < 5) {
g_usleep (50000);
if (dc1394_video_get_transmission (src->camera,
&status) != DC1394_SUCCESS) {
if (status == DC1394_OFF) {
GST_LOG_OBJECT (src, "camera is still off , retrying");
}
}
}
if (i == 5) {
GST_ELEMENT_ERROR (src, RESOURCE, FAILED,
("Camera doesn't seem to want to turn on!"),
("Camera doesn't seem to want to turn on!"));
return FALSE;
}
GST_LOG_OBJECT (src, "got transmision status ON");
} else {
if (dc1394_video_set_transmission (src->camera,
DC1394_OFF) != DC1394_SUCCESS) {
GST_ELEMENT_ERROR (src, RESOURCE, FAILED, ("Unable to stop transmision"),
("Unable to stop transmision"));
return FALSE;
}
GST_LOG_OBJECT (src, "Stopping capture");
err = dc1394_capture_stop (src->camera);
if (err > 0) {
GST_ELEMENT_ERROR (src, RESOURCE, FAILED, ("Capture stop error : %d ",
err), ("Capture stop error : %d ", err));
return FALSE;
} else {
GST_LOG_OBJECT (src, "Capture stoped successfully");
}
}
return TRUE;
}
void ofxLibdc::setTransmit(bool transmit) {
dc1394switch_t cur, target;
dc1394_video_get_transmission(camera, &cur);
target = transmit ? DC1394_ON : DC1394_OFF;
if(cur != target)
dc1394_video_set_transmission(camera, target);
}
/**
* Download image from FireFly
*/
void FFMVCCD::grabImage()
{
dc1394error_t err;
dc1394video_frame_t *frame;
uint32_t uheight, uwidth;
int sub;
uint16_t val;
struct timeval start, end;
// Let's get a pointer to the frame buffer
uint8_t * image = PrimaryCCD.getFrameBuffer();
// Get width and height
int width = PrimaryCCD.getSubW() / PrimaryCCD.getBinX();
int height = PrimaryCCD.getSubH() / PrimaryCCD.getBinY();
memset(image, 0, PrimaryCCD.getFrameBufferSize());
/*-----------------------------------------------------------------------
* stop data transmission
*-----------------------------------------------------------------------*/
gettimeofday(&start, NULL);
for (sub = 0; sub < sub_count; ++sub) {
IDMessage(getDeviceName(), "Getting sub %d of %d", sub, sub_count);
err=dc1394_capture_dequeue(dcam, DC1394_CAPTURE_POLICY_WAIT, &frame);
if (err != DC1394_SUCCESS) {
IDMessage(getDeviceName(), "Could not capture frame");
}
dc1394_get_image_size_from_video_mode(dcam,DC1394_VIDEO_MODE_640x480_MONO16, &uwidth, &uheight);
if (DC1394_TRUE == dc1394_capture_is_frame_corrupt(dcam, frame)) {
IDMessage(getDeviceName(), "Corrupt frame!");
continue;
}
// Fill buffer with random pattern
for (int i=0; i < height ; i++) {
for (int j=0; j < width; j++) {
/* Detect unsigned overflow */
val = ((uint16_t *) image)[i*width+j] + ntohs(((uint16_t*) (frame->image))[i*width+j]);
if (val > ((uint16_t *) image)[i*width+j]) {
((uint16_t *) image)[i*width+j] = val;
} else {
((uint16_t *) image)[i*width+j] = 0xFFFF;
}
}
}
dc1394_capture_enqueue(dcam, frame);
}
err=dc1394_video_set_transmission(dcam,DC1394_OFF);
IDMessage(getDeviceName(), "Download complete.");
gettimeofday(&end, NULL);
IDMessage(getDeviceName(), "Download took %d uS", (int) ((end.tv_sec - start.tv_sec) * 1000000 + (end.tv_usec - start.tv_usec)));
// Let INDI::CCD know we're done filling the image buffer
ExposureComplete(&PrimaryCCD);
}
void CvCaptureCAM_DC1394_v2_CPP::close()
{
if (dcCam)
{
// check for fileno valid before using
int fileno=dc1394_capture_get_fileno(dcCam);
if (fileno>=0 && FD_ISSET(fileno, &dc1394.camFds))
FD_CLR(fileno, &dc1394.camFds);
dc1394_video_set_transmission(dcCam, DC1394_OFF);
dc1394_capture_stop(dcCam);
dc1394_camera_free(dcCam);
dcCam = 0;
started = false;
}
for (int i = 0; i < NIMG; i++)
{
cvReleaseImage(&img[i]);
cvReleaseImage(&maps[i][0]);
cvReleaseImage(&maps[i][1]);
}
if (frameC)
{
if (frameC->image)
free(frameC->image);
free(frameC);
frameC = 0;
}
}
int capture_final(capture_t *cap)
{
int i;
for (i = 0; i < cap->num_active; ++i) {
dc1394_video_set_transmission(cap->cameras[i], DC1394_OFF);
dc1394_capture_stop(cap->cameras[i]);
dc1394_camera_free(cap->cameras[i]);
}
cap->num_active = 0;
free(cap->cameras); cap->cameras = NULL;
if (cap->camera_list != NULL) {
dc1394_camera_free_list(cap->camera_list);
cap->camera_list = NULL;
}
cap->num_cameras = 0;
if (cap->dc1394_cxt != NULL) {
dc1394_free(cap->dc1394_cxt);
cap->dc1394_cxt = NULL;
}
return CAPTURE_SUCCESS;
}
static void pdp_dc1394_free(t_pdp_dc1394 *x)
{
dc1394_video_set_transmission(x->camera, DC1394_OFF);
dc1394_capture_stop(x->camera);
dc1394_camera_free(x->camera);
dc1394_free (x->d);
}
/*-----------------------------------------------------------------------
* Releases the cameras and exits
*-----------------------------------------------------------------------*/
void cleanup_and_exit(dc1394camera_t *camera)
{
dc1394_video_set_transmission(camera, DC1394_OFF);
dc1394_capture_stop(camera);
dc1394_camera_free(camera);
exit(1);
}
void cleanup(void) {
int i;
for (i=0; i < numCameras; i++) {
dc1394_video_set_transmission(cameras[i], DC1394_OFF);
dc1394_capture_stop(cameras[i]);
}
}
int main(int argc, char *argv[])
{
dc1394camera_t * camera;
dc1394error_t err;
dc1394video_frame_t * frame;
dc1394_t * d;
dc1394camera_list_t * list;
d = dc1394_new (); /* Initialize libdc1394 */
if (!d)
return 1;
err=dc1394_camera_enumerate (d, &list); /* Find cameras */
DC1394_ERR_RTN(err,"Failed to enumerate cameras");
if (list->num == 0) { /* Verify that we have at least one camera */
dc1394_log_error("No cameras found");
return 1;
}
camera = dc1394_camera_new (d, list->ids[0].guid); /* Work with first camera */
if (!camera) {
dc1394_log_error("Failed to initialize camera with guid %llx", list->ids[0].guid);
return 1;
}
dc1394_camera_free_list (list);
err=dc1394_capture_setup(camera, 4, DC1394_CAPTURE_FLAGS_DEFAULT); /* Setup capture */
err=dc1394_video_set_transmission(camera, DC1394_ON); /* Start transmission */
err=dc1394_capture_dequeue(camera, DC1394_CAPTURE_POLICY_WAIT, &frame);/* Capture */
DC1394_ERR_RTN(err,"Problem getting an image");
err=dc1394_capture_enqueue(camera, frame); /* Release the buffer */
err=dc1394_video_set_transmission(camera, DC1394_OFF); /* Stop transmission */
err=dc1394_capture_stop(camera); /* Stop capture */
printf("Hello World\n"); /* Hey, this is a HELLO WORLD program!! */
dc1394_camera_free (camera); /* cleanup and exit */
dc1394_free (d);
return 0;
}
VideoIIDC1394::~VideoIIDC1394(void)
{
#if defined(DUNE_WITH_DC1394)
dc1394_video_set_transmission(camera, DC1394_OFF);
dc1394_capture_stop(camera);
dc1394_camera_free(camera);
#endif
}
void FirewireVideo::init_camera(
uint64_t guid, int dma_frames,
dc1394speed_t iso_speed,
dc1394video_mode_t video_mode,
dc1394framerate_t framerate
) {
if(video_mode>=DC1394_VIDEO_MODE_FORMAT7_0)
throw VideoException("format7 modes need to be initialized through the constructor that allows for specifying the roi");
camera = dc1394_camera_new (d, guid);
if (!camera)
throw VideoException("Failed to initialize camera");
// Attempt to stop camera if it is already running
dc1394switch_t is_iso_on = DC1394_OFF;
dc1394_video_get_transmission(camera, &is_iso_on);
if (is_iso_on==DC1394_ON) {
dc1394_video_set_transmission(camera, DC1394_OFF);
}
cout << "Using camera with GUID " << camera->guid << endl;
//-----------------------------------------------------------------------
// setup capture
//-----------------------------------------------------------------------
if( iso_speed >= DC1394_ISO_SPEED_800)
{
err=dc1394_video_set_operation_mode(camera, DC1394_OPERATION_MODE_1394B);
if( err != DC1394_SUCCESS )
throw VideoException("Could not set DC1394_OPERATION_MODE_1394B");
}
err=dc1394_video_set_iso_speed(camera, iso_speed);
if( err != DC1394_SUCCESS )
throw VideoException("Could not set iso speed");
err=dc1394_video_set_mode(camera, video_mode);
if( err != DC1394_SUCCESS )
throw VideoException("Could not set video mode");
err=dc1394_video_set_framerate(camera, framerate);
if( err != DC1394_SUCCESS )
throw VideoException("Could not set framerate");
err=dc1394_capture_setup(camera,dma_frames, DC1394_CAPTURE_FLAGS_DEFAULT);
if( err != DC1394_SUCCESS )
throw VideoException("Could not setup camera - check settings");
//-----------------------------------------------------------------------
// initialise width and height from mode
//-----------------------------------------------------------------------
dc1394_get_image_size_from_video_mode(camera, video_mode, &width, &height);
Start();
}
void
cleanup_cam( PGR_Cam *pgcp )
{
if( IS_CAPTURING(pgcp) ) dc1394_capture_stop( pgcp->pc_cam_p );
if( IS_TRANSMITTING(pgcp) )
dc1394_video_set_transmission( pgcp->pc_cam_p, DC1394_OFF );
/* dc1394_free_camera */
dc1394_camera_free( pgcp->pc_cam_p );
}
void FirewireVideo::Start()
{
if( !running )
{
err=dc1394_video_set_transmission(camera, DC1394_ON);
if( err != DC1394_SUCCESS )
throw VideoException("Could not start camera iso transmission");
running = true;
}
}
FWCamera::~FWCamera()
{
#ifdef AVG_ENABLE_1394_2
dc1394_video_set_transmission(m_pCamera, DC1394_OFF);
dc1394_capture_stop(m_pCamera);
dc1394_camera_free(m_pCamera);
dc1394_free(m_pDC1394);
#endif
AVG_TRACE(Logger::category::CONFIG, Logger::severity::INFO, "Firewire camera closed.");
}
FirewireVideo::~FirewireVideo()
{
Stop();
// Close camera
dc1394_video_set_transmission(camera, DC1394_OFF);
dc1394_capture_stop(camera);
dc1394_camera_free(camera);
dc1394_free (d);
}
void Camera::stop() {
eventLoopTimer->stop();
stopClockPulse();
dc1394_video_set_transmission(camera, DC1394_OFF);
dc1394_capture_stop(camera);
dc1394_camera_free(camera);
dc1394_free (camDict);
emit stopped();
}
void FirewireVideo::Stop()
{
if( running )
{
// Stop transmission
err=dc1394_video_set_transmission(camera,DC1394_OFF);
if( err != DC1394_SUCCESS )
throw VideoException("Could not stop the camera");
running = false;
}
}
void Libdc1394SequenceGrabber::stop()
{
msg(osg::INFO) << "stop" << std::endl;
setRunning(false);
dc1394error_t err;
err=dc1394_video_set_transmission(_camera, DC1394_OFF);
checkSuccess(err, "dc1394_video_set_transmission failed");
dc1394_capture_stop(_camera);
}
static int dc1394_v2_close(AVFormatContext * context)
{
struct dc1394_data *dc1394 = context->priv_data;
dc1394_video_set_transmission(dc1394->camera, DC1394_OFF);
dc1394_capture_stop(dc1394->camera);
dc1394_camera_free(dc1394->camera);
dc1394_free(dc1394->d);
return 0;
}
void Libdc1394SequenceGrabber::start()
{
msg(osg::INFO) << "start" << std::endl;
dc1394error_t err;
initCapture();
if (!_camera) return;
err=dc1394_video_set_transmission(_camera, DC1394_ON);
checkSuccess(err, "dc1394_video_set_transmission failed");
setRunning(true);
}
//--------------------------------------------------------------------
of1394VideoGrabber::~of1394VideoGrabber()
{
if(!failedToInit) // if the init failed, then trying to do this stuff is a very bad idea
{
stopThread();
ofSleepMillis(200);
dc1394_video_set_transmission(camera, DC1394_OFF);
dc1394_capture_stop(camera);
dc1394_camera_free(camera);
dc1394_free (d);
}
}
void cleanup(void) {
int i;
for (i=0; i < numCameras; i++) {
dc1394_video_set_transmission(cameras[i], DC1394_OFF);
dc1394_capture_stop(cameras[i]);
}
if ((void *)window != NULL)
XUnmapWindow(display,window);
if (display != NULL)
XFlush(display);
if (frame_buffer != NULL)
free( frame_buffer );
}
//--------------------------------------------------------------------
void ofxVideoGrabberPtgrey::close(){
if (camera != NULL) {
dc1394_video_set_transmission(camera, DC1394_OFF);
dc1394_capture_stop(camera);
dc1394_camera_free(camera);
}
if (pixels != NULL){
delete[] pixels;
pixels = NULL;
}
tex.clear();
}
void CameraIIDC::stopCapture(){
dc1394error_t err;
err = dc1394_video_set_transmission(cam, DC1394_OFF);
err = dc1394_capture_stop(cam);
// // Disable trigger
// err=dc1394_external_trigger_set_power(cam, DC1394_OFF);
// if (err!=DC1394_SUCCESS)
// cerr << "libdc1394: Could not set external trigger on!";
capturing = false;
}
bool Camera::Init()
{
// VideoCapture Interface
cv_image_ = cvCreateImage(cvSize(640,480), IPL_DEPTH_8U, 3);
// Initialize libdc1394
if ((d = dc1394_new ()) == NULL)
return false;
// Find cameras
err = dc1394_camera_enumerate(d, &list);
DC1394_ERR_RTN(err, "Failed to enumerate cameras");
// Verify that we have at least one cameraDC1394_BYTE_ORDER_YUYV
if(list->num == 0)
{
dc1394_log_error("No cameras found");
return false;
}
// Work with first camera found
if ((camera = dc1394_camera_new (d, list->ids[0].guid)) == NULL)
{
dc1394_log_error("Failed to initialize camera with guid %llx", list->ids[0].guid);
return false;
}
// Not using the list anymore, clean it up
dc1394_camera_free_list(list);
// Power ON
dc1394_camera_set_power(camera, DC1394_ON);
// Print camera info
dc1394_camera_print_info(camera, stdout);
// Setup capture
err = dc1394_capture_setup(camera, 4, DC1394_CAPTURE_FLAGS_DEFAULT);
// Set video mode
dc1394_video_set_mode(camera, DC1394_VIDEO_MODE_640x480_YUV422);
// Start transmission
err = dc1394_video_set_transmission(camera, DC1394_ON);
// VideoCapture Interface
init_ = true;
return true;
}
int _stopCam(){
if(camera==NULL) {
dc1394_log_error("Camera is not initialised");
return -1;
}
/*-----------------------------------------------------------------------
* stop data transmission
*-----------------------------------------------------------------------*/
err=dc1394_video_set_transmission(camera,DC1394_OFF);
DC1394_ERR_CLN_RTN(err,_unsetupCam(),"Could not stop transmission of the camera");
err=dc1394_capture_stop(camera);
DC1394_ERR_CLN_RTN(err,_unsetupCam(),"Could not stop capture of the camera");
return 0;
}
Libdc1394Grabber::~Libdc1394Grabber()
{
cout << "libdcgrabber destructor" << endl;
if (camera != NULL )
{
ofLog(OF_LOG_NOTICE ,"Stopping ISO transmission.");
// Stop data transmission
if (dc1394_video_set_transmission(camera,DC1394_OFF)!=DC1394_SUCCESS)
{
ofLog(OF_LOG_ERROR, "Could not stop ISO transmission!");
}
// Close camera
cleanupCamera();
}
}
void
DisplayStatsAndExit(int sig)
{
int i;
fprintf(stderr,"\nFramerate statistics:\n");
fprintf(stderr,"bin centers:\t[");
for (i=0;i<bin_n;i++) {
if (i==0)
fprintf(stderr,"<");
fprintf(stderr,"%3.1f",(float)bin_min+(float)(bin_max-bin_min)/(float)bin_n*((float)i+.5));
if (i==bin_n-1)
fprintf(stderr,">");
if (i<bin_n)
fprintf(stderr,"\t");
}
fprintf(stderr,"]\n");
fprintf(stderr,"histogram:\t[");
for (i=0;i<bin_n;i++) {
if (bins[i]!=0)
fprintf(stderr,"%d",bins[i]);
else
fprintf(stderr," ");
if (i<bin_n)
fprintf(stderr,"\t");
}
fprintf(stderr,"]\n");
fprintf(stderr,"percentage:\t[");
for (i=0;i<bin_n;i++) {
if (bins[i]!=0)
fprintf(stderr,"%3.1f",(float)bins[i]/nframes*100);
else
fprintf(stderr," ");
if (i<bin_n)
fprintf(stderr,"\t");
}
fprintf(stderr,"]\n");
free(bins);
SDL_Quit();
dc1394_video_set_transmission(camera, DC1394_OFF);
dc1394_capture_stop(camera);
dc1394_camera_free (camera);
dc1394_free(d);
exit(0);
}
void ieee1394capture::cleanup()
{
int32_t i;
if (CREATED_CAMS == true)
{
for (i = 0; i < numCameras; i++) {
dc1394_video_set_transmission(cameras[i], DC1394_OFF);
dc1394_capture_stop(cameras[i]);
}
CREATED_CAMS=false;
}
if ( CREATED_BUS == true )
{
dc1394_free(d);
CREATED_BUS=false;
}
}
static int s_activate_camera(capture_t *cap, const int index)
{
s_flush_buffer(cap, index);
if ((!cap->prefer_one_shot) || cap->cameras[index]->one_shot_capable != DC1394_TRUE) {
dc1394error_t err;
/* use continuous transmission mode */
err = dc1394_video_set_transmission(cap->cameras[index], DC1394_ON);
DC1394_WRN(err, "could not start iso transmission");
if (err != DC1394_SUCCESS) {
return CAPTURE_ERROR;
}
}
return CAPTURE_SUCCESS;
}
