thread_iso.c

Coriander is a GUI for controlling a Digital Camera (in the sense of the IIDC specs issued by the 1

  }

}


gint IsoStopThread(camera_t* cam)
{
  isothread_info_t *info;
  chain_t *iso_service;
  iso_service=GetService(cam,SERVICE_ISO);  

  if (iso_service!=NULL) { // if ISO service running...
    info=(isothread_info_t*)iso_service->data;
    pthread_cancel(iso_service->thread);
    pthread_join(iso_service->thread, NULL);
    pthread_mutex_lock(&iso_service->mutex_data);
    pthread_mutex_lock(&iso_service->mutex_struct);

    RemoveChain(cam,iso_service);
    
    if ((info->temp!=NULL)&&(info->temp_allocated>0)) {
      free(info->temp);
      info->temp=NULL;
      info->temp_allocated=0;
      info->temp_size=0;
    }
    
    if (info->receive_method == RECEIVE_METHOD_VIDEO1394) {
      dc1394_dma_unlisten(cam->camera_info.handle, &info->capture);
      dc1394_dma_release_camera(info->handle, &info->capture);
    }
    else 
      dc1394_release_camera(cam->camera_info.handle, &info->capture);
    
    dc1394_destroy_handle(info->handle);
    info->handle = NULL;
    
    pthread_mutex_unlock(&iso_service->mutex_struct);
    pthread_mutex_unlock(&iso_service->mutex_data);
    
    FreeChain(iso_service);
    
  }
  
  return (1);
}


void
IsoThreadCheckParams(chain_t *iso_service)
{

  isothread_info_t *info;
  info=(isothread_info_t*)iso_service->data;
  // copy harmless parameters anyway:
  pthread_mutex_lock(&iso_service->camera->uimutex);

  iso_service->current_buffer->bpp=iso_service->camera->bpp;
  iso_service->current_buffer->bayer_pattern=iso_service->camera->bayer_pattern;
  iso_service->current_buffer->width=info->capture.frame_width;
  iso_service->current_buffer->height=info->capture.frame_height;
  iso_service->current_buffer->bytes_per_frame=info->capture.quadlets_per_frame*4;
  iso_service->current_buffer->mode=iso_service->camera->misc_info.mode;
  iso_service->current_buffer->format=iso_service->camera->misc_info.format;
  iso_service->current_buffer->format7_color_mode=iso_service->camera->format7_info.mode[iso_service->camera->misc_info.mode-MODE_FORMAT7_MIN].color_coding_id;
  iso_service->current_buffer->stereo_decoding=iso_service->camera->stereo;
  iso_service->current_buffer->bayer=iso_service->camera->bayer;
  info->orig_sizex=iso_service->current_buffer->width;
  info->orig_sizey=iso_service->current_buffer->height;

  if (iso_service->current_buffer->format!=FORMAT_SCALABLE_IMAGE_SIZE) {
    info->cond16bit=((iso_service->current_buffer->mode==MODE_640x480_MONO16)||
		     (iso_service->current_buffer->mode==MODE_800x600_MONO16)||
		     (iso_service->current_buffer->mode==MODE_1024x768_MONO16)||
		     (iso_service->current_buffer->mode==MODE_1280x960_MONO16)||
		     (iso_service->current_buffer->mode==MODE_1600x1200_MONO16));
  }
  else {
    // warning: little change, might have big effect
    info->cond16bit=(iso_service->camera->format7_info.mode[iso_service->current_buffer->mode-MODE_FORMAT7_MIN].color_coding_id==COLOR_FORMAT7_MONO16);
  }

  // the buffer sizes. If a size is not good, re-allocate.
  switch (iso_service->current_buffer->bayer) {
  case BAYER_DECODING_DOWNSAMPLE:
    switch (iso_service->current_buffer->stereo_decoding) {
    case STEREO_DECODING_FIELD:
    case STEREO_DECODING_INTERLACED:
      // height is the same (/2 downsampling, *2 stereo decoding)
      iso_service->current_buffer->width/=2;
      iso_service->current_buffer->bytes_per_frame=iso_service->current_buffer->width*iso_service->current_buffer->height*3; // RGB buffer -> *3
      AllocImageBuffer(iso_service);
      AllocTempBuffer(info->orig_sizey*info->orig_sizex*2*sizeof(unsigned char),info);
      break;
    case NO_STEREO_DECODING:
      iso_service->current_buffer->width/=2;
      iso_service->current_buffer->height/=2;
      iso_service->current_buffer->bytes_per_frame=iso_service->current_buffer->width*iso_service->current_buffer->height*3; // RGB buffer -> *3
      AllocImageBuffer(iso_service);
      if (info->cond16bit!=0)
	AllocTempBuffer(info->orig_sizey*info->orig_sizex*sizeof(unsigned char),info);
      else {
	AllocTempBuffer(0,info);
      }
      break;
    }
    break;
  case BAYER_DECODING_EDGE_SENSE:
  case BAYER_DECODING_NEAREST:
  case BAYER_DECODING_SIMPLE:
    switch (iso_service->current_buffer->stereo_decoding) {
    case STEREO_DECODING_FIELD:
    case STEREO_DECODING_INTERLACED:
      iso_service->current_buffer->height*=2;
      iso_service->current_buffer->bytes_per_frame=iso_service->current_buffer->width*iso_service->current_buffer->height*3; // RGB buffer -> *3
      AllocImageBuffer(iso_service);
      AllocTempBuffer(info->orig_sizey*info->orig_sizex*2*sizeof(unsigned char),info);
      break;
    case NO_STEREO_DECODING:
      iso_service->current_buffer->bytes_per_frame=iso_service->current_buffer->width*iso_service->current_buffer->height*3; // RGB buffer -> *3
      AllocImageBuffer(iso_service);
      if (info->cond16bit!=0)
	AllocTempBuffer(info->orig_sizey*info->orig_sizex*sizeof(unsigned char),info);
      else {
	AllocTempBuffer(0,info);
      }
      break;
    }
    break;
  case NO_BAYER_DECODING:
    switch (iso_service->current_buffer->stereo_decoding) {
    case STEREO_DECODING_FIELD:
    case STEREO_DECODING_INTERLACED:
      iso_service->current_buffer->height*=2;
      iso_service->current_buffer->bytes_per_frame=iso_service->current_buffer->width*iso_service->current_buffer->height; // GRAY output only (8bpp)
      AllocImageBuffer(iso_service);
      AllocTempBuffer(0,info);
      //fprintf(stderr,"info->temp linked to curent image buffer\n");
      // it is very important to allocate the image buffer before the following
      // assignation because the image allocation might change the buffer pointer! 
      info->temp=(unsigned char *)iso_service->current_buffer->image;
      break;
    case NO_STEREO_DECODING:
      AllocImageBuffer(iso_service);
      AllocTempBuffer(0,info);
      break;
    }
    break;
  }
  SetColorMode(iso_service->current_buffer);
  
  pthread_mutex_unlock(&iso_service->camera->uimutex);

}

void
AllocTempBuffer(long long unsigned int requested_size, isothread_info_t* info) 
{
  if (requested_size==0) {
    if (info->temp_allocated>0) {
      free(info->temp);
    }
    info->temp_allocated=0;
    info->temp_size=0;
    }
  else { // some allocated space is required
    if (requested_size!=info->temp_size) { // req and actual size don't not match
      if (info->temp_allocated>0) {
	free(info->temp);
      }
      info->temp=(unsigned char *)malloc(requested_size*sizeof(unsigned char));
      info->temp_allocated=1;
      info->temp_size=requested_size;
    }
  }
}

void
AllocImageBuffer(chain_t* iso_service) 
{
  // ============ Allocate standard buffer ===============
  if (iso_service->current_buffer->buffer_size!=iso_service->current_buffer->bytes_per_frame) {
    // (re)allocation is necessary
    if (iso_service->current_buffer->image!=NULL) {
      free(iso_service->current_buffer->image);
      iso_service->current_buffer->image=NULL;
    }
    iso_service->current_buffer->image=(unsigned char*)malloc(iso_service->current_buffer->bytes_per_frame*sizeof(unsigned char));
    iso_service->current_buffer->buffer_size=iso_service->current_buffer->bytes_per_frame;
  }
}

void
SetColorMode(buffer_t *buffer)
{
  float bpp=-1;

  if (buffer->bayer==NO_BAYER_DECODING) {
    switch(buffer->mode) {
    case MODE_160x120_YUV444:
      buffer->buffer_color_mode=COLOR_FORMAT7_YUV444;
      bpp=3;
      break;
    case MODE_320x240_YUV422:
    case MODE_640x480_YUV422:
    case MODE_800x600_YUV422:
    case MODE_1024x768_YUV422:
    case MODE_1280x960_YUV422:
    case MODE_1600x1200_YUV422:
      if (buffer->stereo_decoding!=NO_STEREO_DECODING) {
	buffer->buffer_color_mode=COLOR_FORMAT7_MONO8;
	bpp=1;
      }
      else {
	buffer->buffer_color_mode=COLOR_FORMAT7_YUV422;
	bpp=2;
      }
      break;
    case MODE_640x480_YUV411:
      buffer->buffer_color_mode=COLOR_FORMAT7_YUV411;
      bpp=1.5;
      break;
    case MODE_640x480_RGB:
    case MODE_800x600_RGB:
    case MODE_1024x768_RGB:
    case MODE_1280x960_RGB:
    case MODE_1600x1200_RGB:
      buffer->buffer_color_mode=COLOR_FORMAT7_RGB8;
      bpp=3;
      break;
    case MODE_640x480_MONO:
    case MODE_800x600_MONO:
    case MODE_1024x768_MONO:
    case MODE_1280x960_MONO:
    case MODE_1600x1200_MONO:
      buffer->buffer_color_mode=COLOR_FORMAT7_MONO8;
      bpp=1;
      break;
    case MODE_640x480_MONO16:
    case MODE_800x600_MONO16:
    case MODE_1024x768_MONO16:
    case MODE_1280x960_MONO16:
    case MODE_1600x1200_MONO16:
      if (buffer->stereo_decoding!=NO_STEREO_DECODING) {
	buffer->buffer_color_mode=COLOR_FORMAT7_MONO8;
	bpp=1;
      }
      else {
	buffer->buffer_color_mode=COLOR_FORMAT7_MONO16;
	bpp=2;
      }
      break;
    case MODE_FORMAT7_0:
    case MODE_FORMAT7_1:
    case MODE_FORMAT7_2:
    case MODE_FORMAT7_3:
    case MODE_FORMAT7_4:
    case MODE_FORMAT7_5:
    case MODE_FORMAT7_6:
    case MODE_FORMAT7_7:
      if ((buffer->format7_color_mode==COLOR_FORMAT7_MONO16)&&(buffer->stereo_decoding!=NO_STEREO_DECODING)) {
	buffer->buffer_color_mode=COLOR_FORMAT7_MONO8;
	bpp=1;
      }
      else {
	buffer->buffer_color_mode=buffer->format7_color_mode;
	switch (buffer->format7_color_mode) {
	case COLOR_FORMAT7_MONO8:
	  bpp=1;
	  break;
	case COLOR_FORMAT7_MONO16:
	  bpp=2;
	  break;
	case COLOR_FORMAT7_RGB8:
	  bpp=3;
	  break;
	case COLOR_FORMAT7_RGB16:
	  bpp=6;
	  break;
	case COLOR_FORMAT7_YUV444:
	  bpp=3;
	  break;
	case COLOR_FORMAT7_YUV422:
	  bpp=2;
	  break;
	case COLOR_FORMAT7_YUV411:
	  bpp=1.5;
	  break;
	}
      }
      break;
    }
  }
  else  { // we force RGB mode
    buffer->buffer_color_mode=COLOR_FORMAT7_RGB8;
    bpp=3;
  }

  if (bpp==-1)
    fprintf(stderr,"ERROR: BPP is -1!!\n");

  buffer->buffer_image_bytes=(int)(buffer->width*buffer->height*bpp);

}