static int dc1394_read_packet(AVFormatContext *c, AVPacket *pkt) { struct dc1394_data *dc1394 = c->priv_data; int res; /* discard stale frame */ if (dc1394->current_frame++) { if (dc1394_dma_done_with_buffer(&dc1394->camera) != DC1394_SUCCESS) av_log(c, AV_LOG_ERROR, "failed to release %d frame\n", dc1394->current_frame); } res = dc1394_dma_single_capture(&dc1394->camera); if (res == DC1394_SUCCESS) { dc1394->packet.data = (uint8_t *)(dc1394->camera.capture_buffer); dc1394->packet.pts = (dc1394->current_frame * 1000000) / dc1394->fps; res = dc1394->packet.size; } else { av_log(c, AV_LOG_ERROR, "DMA capture failed\n"); dc1394->packet.data = NULL; res = -1; } *pkt = dc1394->packet; return res; }
static void *capture_loop( void *d ) { struct dc1394_input *conf = (struct dc1394_input *)d; struct frame *f; int cam; for(;;) { dc1394_dma_multi_capture( conf->camera, conf->cam_count ); for( cam = 0; cam < conf->cam_count; ++cam ) { if( conf->cam[cam].running && ( f = new_frame() ) ) { f->length = HEIGHT * WIDTH * 2; f->format = FORMAT_RAW_UYVY; f->width = WIDTH; f->height = HEIGHT; f->key = 1; memcpy( f->d, conf->camera[cam].capture_buffer, f->length ); if( soft_queue_add( conf->cam[cam].outq, f ) < 0 ) unref_frame( f ); } dc1394_dma_done_with_buffer( &conf->camera[cam] ); } } return NULL; }
/***************************************************************************** * Demux: *****************************************************************************/ static block_t *GrabVideo( demux_t *p_demux ) { demux_sys_t *p_sys = p_demux->p_sys; block_t *p_block = NULL; int result = 0; if( p_sys->dma_capture ) { result = dc1394_dma_single_capture( &p_sys->camera ); if( result != DC1394_SUCCESS ) { msg_Err( p_demux, "unable to capture a frame" ); return NULL; } } else { result = dc1394_single_capture( p_sys->camera_info.handle, &p_sys->camera ); if( result != DC1394_SUCCESS ) { msg_Err( p_demux, "unable to capture a frame" ); return NULL; } } p_block = block_New( p_demux, p_sys->camera.frame_width * p_sys->camera.frame_height * 2 ); if( !p_block ) { msg_Err( p_demux, "cannot get block" ); return NULL; } if( !p_sys->camera.capture_buffer ) { msg_Err (p_demux, "caputer buffer empty"); block_Release( p_block ); return NULL; } memcpy( p_block->p_buffer, (const char *)p_sys->camera.capture_buffer, p_sys->camera.frame_width * p_sys->camera.frame_height * 2 ); p_block->i_pts = p_block->i_dts = mdate(); if( p_sys->dma_capture ) dc1394_dma_done_with_buffer( &p_sys->camera ); return p_block; }
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 IplImage* icvRetrieveFrameCAM_DC1394( CvCaptureCAM_DC1394* capture ){ if(capture->camera->capture_buffer ) { if(capture->convert){ /* Convert to RGBA */ unsigned char * src = (unsigned char *)capture->camera->capture_buffer; unsigned char * dst = (unsigned char *)capture->frame.imageData; switch (capture->color_mode) { case COLOR_FORMAT7_RGB8: printf("icvRetrieveFrame convert RGB to BGR\n"); /* Convert RGB to BGR */ for (int i=0;i<capture->frame.imageSize;i+=6) { dst[i] = src[i+2]; dst[i+1] = src[i+1]; dst[i+2] = src[i]; dst[i+3] = src[i+5]; dst[i+4] = src[i+4]; dst[i+5] = src[i+3]; } break; case COLOR_FORMAT7_YUV422: //printf("icvRetrieveFrame convert YUV422 to BGR %d\n"); uyvy2bgr(src, dst, capture->camera->frame_width * capture->camera->frame_height); break; case COLOR_FORMAT7_MONO8: //printf("icvRetrieveFrame convert MONO8 to BGR %d\n"); y2bgr(src, dst, capture->camera->frame_width * capture->camera->frame_height); break; case COLOR_FORMAT7_YUV411: //printf("icvRetrieveFrame convert YUV411 to BGR %d\n"); uyyvyy2bgr(src, dst, capture->camera->frame_width * capture->camera->frame_height); break; case COLOR_FORMAT7_YUV444: //printf("icvRetrieveFrame convert YUV444 to BGR %d\n"); uyv2bgr(src, dst, capture->camera->frame_width * capture->camera->frame_height); break; case COLOR_FORMAT7_MONO16: //printf("icvRetrieveFrame convert MONO16 to BGR %d\n"); y162bgr(src, dst, capture->camera->frame_width * capture->camera->frame_height, MONO16_BPP); break; case COLOR_FORMAT7_RGB16: //printf("icvRetrieveFrame convert RGB16 to BGR %d\n"); rgb482bgr(src, dst, capture->camera->frame_width * capture->camera->frame_height, MONO16_BPP); break; default: fprintf(stderr,"%s:%d: Unsupported color mode %d\n",__FILE__,__LINE__,capture->color_mode); return 0; } /* switch (capture->mode) */ } else{ // return raw data capture->frame.imageData = (char *) capture->camera->capture_buffer; capture->frame.imageDataOrigin = (char *) capture->camera->capture_buffer; } // TODO: if convert=0, we are not actually done with the buffer // but this seems to work anyway. dc1394_dma_done_with_buffer(capture->camera); return &capture->frame; } return 0; };
//--------------------------------------------------------------- void BufferManager1394::releaseOutputBuffer() { dc1394_dma_done_with_buffer(pCamera_); }
int CameraDcam::moduleLoop(void) { camera_data_msg* p_data = NULL; ssize_t datalength = 0; rack_time_t starttime; int h=0,w=0,p=0; int ret; starttime = rackTime.get(); // get datapointer from databuffer p_data = (camera_data_msg *)getDataBufferWorkSpace(); p_data->data.recordingTime = rackTime.get(); p_data->data.mode = mode; p_data->data.colorFilterId = format7image.colorFilterId; switch (mode){ case CAMERA_MODE_MONO8: case CAMERA_MODE_RAW8: p_data->data.depth = 8; break; case CAMERA_MODE_RAW12: case CAMERA_MODE_YUV422: p_data->data.depth = 16; break; default: GDOS_ERROR("Unknown mode %i \n",mode); return -1; } /*----------------------------------------------------------------------- * capture one frame and send to mbx *-----------------------------------------------------------------------*/ GDOS_DBG_INFO("Capturing one image\n"); if ((ret = dc1394_dma_single_capture( &dc1394Camera ))!=DC1394_SUCCESS) { GDOS_WARNING("Unable to capture a frame. ret = %i \n", ret); } else { p_data->data.width = dc1394Camera.frame_width / lossRate; p_data->data.height = dc1394Camera.frame_height / lossRate; //shrink data if set to. if (lossRate == 1) { memcpy(p_data->byteStream, dc1394Camera.capture_buffer, dc1394Camera.dma_frame_size ); } else { /*lossRate != 1 so we need to throw some pixel away. -> iterate over array. *The loss in YUV422 format must lose pairs of pixel! as UYVY pairs cannot be divided up!! * ->from 4 pixel in the original only one pixelPair! is transmitted. * eg. lossrate of 2 in yuv -> take 4 byte, leave 4 byte, take 4 byte.... leave a row... * *The loss in RAW format must also lose pairs of pixel! ohterwise only one color may result. */ int pairfactor = 2; //depending on colorMode (Yuv=Raw=2, mono=1) int bytesPerPixelPair = 0; if (p_data->data.mode==CAMERA_MODE_MONO8 ||p_data->data.mode==CAMERA_MODE_RGB24 || p_data->data.mode==CAMERA_MODE_MONO12) pairfactor = 1; bytesPerPixelPair = bytesPerPixel * pairfactor;//to save multiplications //copy needed to change datatypes memcpy(dataBuffer, dc1394Camera.capture_buffer, dc1394Camera.dma_frame_size ); for (h=0; h < p_data->data.height; h++) { //for every line in the smaller image for(w=0; w < p_data->data.width / pairfactor; w++) { //for every pixelPair in the smaller image for (p=0; p<bytesPerPixelPair; p++) { //for every byte per pixelPair p_data->byteStream[ (h*bytesPerPixel*p_data->data.width) + (w*bytesPerPixelPair) + p] = dataBuffer[(h*bytesPerPixel*dc1394Camera.frame_width*lossRate) + (w*bytesPerPixelPair*lossRate) + p]; } } } GDOS_DBG_DETAIL("Data width %i pixelPairs to be send height %i pixel(!) bppp %i\n", w, h, p); } //end of lossRate calculation //doing auto shutter / gain / brightness control autoBrightness(p_data); if (whitebalanceMode > 0) { autoWhitebalance(p_data); } GDOS_DBG_DETAIL("Data recordingtime %i width %i height %i depth %i mode %i\n", p_data->data.recordingTime, p_data->data.width, p_data->data.height, p_data->data.depth, p_data->data.mode); datalength = p_data->data.width * p_data->data.height * bytesPerPixel + sizeof(camera_data); putDataBufferWorkSpace(datalength); dc1394_dma_done_with_buffer( &dc1394Camera );//return the buffer handle to library. } //rt_sleep(timeCount1s/fps);//## zeitverwaltung zentral erledigt RackTask::sleep((1000000000llu/fps) - (rackTime.get() - starttime)); return 0; }
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; }
void capture_frame() { static int have_warned = 0; dc1394_dma_multi_capture(cameras, numCameras); if (!freeze && adaptor >= 0) { for (int i = 0; i < numCameras; i++) { // create OpenCV image switch (res) { case MODE_640x480_YUV411: if (!have_warned) { have_warned = 1; printf("WARNING: no OpenCV conversion available for this format\n"); } //iyu12yuy2((unsigned char *) cameras[i].capture_buffer, // frame_buffer + (i * frame_length), // (device_width * device_height)); break; case MODE_320x240_YUV422: case MODE_640x480_YUV422: if (!have_warned) { have_warned = 1; printf("WARNING: no OpenCV conversion available for this format\n"); } // memcpy(frame_buffer + (i * frame_length), // cameras[i].capture_buffer, device_width * device_height * 2); break; case MODE_640x480_RGB: // don't convert for OpenCV, this is the correct format readOnlyImg->imageData = (char *) cameras[i].capture_buffer; if (async_processing) { if (i==0) { hvAsyncGetImageBuffer(&m_async_image, &m_async_bufID); cvCopy(readOnlyImg, m_async_image); } } else { cvCopy(readOnlyImg, iplImages[i]); } break; } if (verbose) { CvFont font; cvInitFont(&font, CV_FONT_VECTOR0, 0.5f /* hscale */ , 0.5f /* vscale */ , 0.1f /*italic_scale */ , 1 /* thickness */ , 8); char str[256]; sprintf(str, "camera id: %d", i); CvSize textsize; int underline; cvGetTextSize(str, &font, &textsize, &underline); CvPoint pos = cvPoint(iplImages[i]->width - textsize.width - 5, textsize.height + 10); cvPutText(iplImages[i], str, pos, &font, CV_RGB(0, 255, 0)); // cvRectangle(iplImages[i], cvPoint(10, 10), cvPoint(100, 100), // cvScalar(255, 255, 255, 255), CV_FILLED, 8, 0); } } } for (int i = 0; i < numCameras; i++) { dc1394_dma_done_with_buffer(&cameras[i]); } }