dc1394_format7.c

This library provides functionality to control any camera that conforms to the 1394-Based Digital C

      color_codings->codings[color_codings->num]=i+DC1394_COLOR_CODING_MIN;
      color_codings->num++;
    }
  }
  
  //fprintf(stderr,"number of modes: %d\n",modes->num);
  return err;
}
 
dc1394error_t
dc1394_format7_get_pixel_number(dc1394camera_t *camera,
 				dc1394video_mode_t video_mode,
				uint_t *pixnum)
{
  dc1394error_t err;
  quadlet_t value;
  
  if (!dc1394_is_video_mode_scalable(video_mode))
    return DC1394_INVALID_VIDEO_MODE;

  err=GetCameraFormat7Register(camera, video_mode, REG_CAMERA_FORMAT7_PIXEL_NUMBER_INQ, &value);
  DC1394_ERR_RTN(err, "Could not get pixel number");

  *pixnum= (uint_t) value;
  
  return err;
}

dc1394error_t
dc1394_format7_get_total_bytes(dc1394camera_t *camera,
			       dc1394video_mode_t video_mode,
			       uint64_t *total_bytes)
{
  dc1394error_t err;
  uint64_t value_hi, value_lo;
  quadlet_t value;
  
  if (!dc1394_is_video_mode_scalable(video_mode))
    return DC1394_INVALID_VIDEO_MODE;
  
  err=GetCameraFormat7Register(camera, video_mode, REG_CAMERA_FORMAT7_TOTAL_BYTES_HI_INQ, &value);
  DC1394_ERR_RTN(err, "Could not get total bytes - LSB");

  value_hi=value;
  
  err=GetCameraFormat7Register(camera, video_mode, REG_CAMERA_FORMAT7_TOTAL_BYTES_LO_INQ, &value);
  DC1394_ERR_RTN(err, "Could not get total bytes - MSB");

  value_lo=value;
  
  *total_bytes= (value_lo | ( value_hi << 32) ); 
  
  return err;
}

dc1394error_t
dc1394_format7_get_packet_para(dc1394camera_t *camera,
			       dc1394video_mode_t video_mode, uint_t *min_bytes,
			       uint_t *max_bytes)
{
  dc1394error_t err;
  quadlet_t value;
  
  if (!dc1394_is_video_mode_scalable(video_mode))
    return DC1394_INVALID_VIDEO_MODE;
  
  err= GetCameraFormat7Register(camera, video_mode, REG_CAMERA_FORMAT7_PACKET_PARA_INQ, &value);
  DC1394_ERR_RTN(err, "Could not get F7 packet parameters");

  *min_bytes= (uint_t) ( value & 0xFFFF0000UL ) >> 16;
  *max_bytes= (uint_t) ( value & 0x0000FFFFUL );       
  
  return err;
}

dc1394error_t
dc1394_format7_get_byte_per_packet(dc1394camera_t *camera,
				   dc1394video_mode_t video_mode,
				   uint_t *packet_bytes)
{
  dc1394error_t err;
  quadlet_t value;
  
  if (!dc1394_is_video_mode_scalable(video_mode))
    return DC1394_INVALID_VIDEO_MODE;

  err=GetCameraFormat7Register(camera, video_mode, REG_CAMERA_FORMAT7_BYTE_PER_PACKET, &value);
  DC1394_ERR_RTN(err, "Could not get bytes per packet");

  *packet_bytes= (uint_t) ( value & 0xFFFF0000UL ) >> 16;
  
  if (packet_bytes==0) {
    printf("(%s): BYTES_PER_PACKET is zero. This should not happen.\n", __FILE__);
    return DC1394_FAILURE;
  }
  return err;
}

dc1394error_t
dc1394_format7_set_image_position(dc1394camera_t *camera,
 				  dc1394video_mode_t video_mode, uint_t left,
 				  uint_t top)
{
  dc1394error_t err;

  if (!dc1394_is_video_mode_scalable(video_mode))
    return DC1394_INVALID_VIDEO_MODE;

  err=SetCameraFormat7Register(camera, video_mode, REG_CAMERA_FORMAT7_IMAGE_POSITION, (quadlet_t)((left << 16) | top));
  DC1394_ERR_RTN(err, "Format7 image position setting failure");

  // IIDC v1.30 handshaking:
  err=_dc1394_v130_handshake(camera, video_mode);
  DC1394_ERR_RTN(err, "F7 handshake failure");

  return err;
}

dc1394error_t
dc1394_format7_set_image_size(dc1394camera_t *camera,
                              dc1394video_mode_t video_mode, uint_t width,
                              uint_t height)
{
  dc1394error_t err;

  if (camera->capture_is_set>0)
    return DC1394_CAPTURE_IS_RUNNING;

  if (!dc1394_is_video_mode_scalable(video_mode))
    return DC1394_INVALID_VIDEO_MODE;

  err=SetCameraFormat7Register(camera, video_mode, REG_CAMERA_FORMAT7_IMAGE_SIZE, (quadlet_t)((width << 16) | height));
  DC1394_ERR_RTN(err, "Format7 image size setting failure");

  // IIDC v1.30 handshaking:
  err=_dc1394_v130_handshake(camera, video_mode);
  DC1394_ERR_RTN(err, "F7 handshake failure");

  return err;
}

dc1394error_t
dc1394_format7_set_color_coding(dc1394camera_t *camera,
				dc1394video_mode_t video_mode, dc1394color_coding_t color_coding)
{
  dc1394error_t err;

  if (camera->capture_is_set>0)
    return DC1394_CAPTURE_IS_RUNNING;

  if (!dc1394_is_video_mode_scalable(video_mode))
    return DC1394_INVALID_VIDEO_MODE;
  
  color_coding-= DC1394_COLOR_CODING_MIN;
  color_coding=color_coding<<24;
  err=SetCameraFormat7Register(camera, video_mode,REG_CAMERA_FORMAT7_COLOR_CODING_ID, (quadlet_t)color_coding);
  DC1394_ERR_RTN(err, "Format7 color coding ID setting failure");

  // IIDC v1.30 handshaking:
  err=_dc1394_v130_handshake(camera, video_mode);
  DC1394_ERR_RTN(err, "F7 handshake failure");

  return err;
}

dc1394error_t
dc1394_format7_set_byte_per_packet(dc1394camera_t *camera,
 				   dc1394video_mode_t video_mode,
                                   uint_t packet_bytes)
{
  dc1394error_t err;

  if (camera->capture_is_set>0)
    return DC1394_CAPTURE_IS_RUNNING;

  if (!dc1394_is_video_mode_scalable(video_mode))
    return DC1394_INVALID_VIDEO_MODE;

  err=SetCameraFormat7Register(camera, video_mode, REG_CAMERA_FORMAT7_BYTE_PER_PACKET, (quadlet_t)(packet_bytes) << 16 );
  DC1394_ERR_RTN(err, "Format7 bytes-per-packet setting failure");

  // IIDC v1.30 handshaking:
  err=_dc1394_v130_handshake(camera, video_mode);
  DC1394_ERR_RTN(err, "F7 handshake failure");

  return err;
}

dc1394error_t
dc1394_format7_get_recommended_byte_per_packet(dc1394camera_t *camera,
					       dc1394video_mode_t video_mode, uint_t *bpp)
{
  dc1394error_t err;
  quadlet_t value;
  
  if (!dc1394_is_video_mode_scalable(video_mode))
    return DC1394_INVALID_VIDEO_MODE;
  
  err= GetCameraFormat7Register(camera, video_mode, REG_CAMERA_FORMAT7_BYTE_PER_PACKET, &value);
  DC1394_ERR_RTN(err, "Could not get recommended BPP");

  *bpp= (uint_t) ( value & 0x0000FFFFUL );
  
  return err;
}

dc1394error_t
dc1394_format7_get_packet_per_frame(dc1394camera_t *camera,
				    dc1394video_mode_t video_mode, uint_t *ppf)
{
  dc1394error_t err;
  quadlet_t value;
  uint_t packet_bytes;
  uint64_t total_bytes;

  if (!dc1394_is_video_mode_scalable(video_mode))
    return DC1394_INVALID_VIDEO_MODE;
    
  if (camera->iidc_version>=DC1394_IIDC_VERSION_1_30) {

    err= GetCameraFormat7Register(camera, video_mode, REG_CAMERA_FORMAT7_PACKET_PER_FRAME_INQ, &value);
    DC1394_ERR_RTN(err, "Could not get the number of packets per frame");

    *ppf= (uint_t) (value);
    
    return err;
  }
  else {
    // return an estimate, NOT TAKING ANY PADDING INTO ACCOUNT
    err=dc1394_format7_get_byte_per_packet(camera, video_mode, &packet_bytes);
    DC1394_ERR_RTN(err, "Could not get BPP");

    if (packet_bytes==0) {
      return DC1394_FAILURE;
    }

    err=dc1394_format7_get_total_bytes(camera, video_mode, &total_bytes);
    DC1394_ERR_RTN(err, "Could not get total number of bytes");

    if (total_bytes%packet_bytes!=0)
      *ppf=total_bytes/packet_bytes+1;
    else
      *ppf=total_bytes/packet_bytes;
    
    return err;
  }
  
}

dc1394error_t
dc1394_format7_get_unit_position(dc1394camera_t *camera,
				 dc1394video_mode_t video_mode,
				 uint_t *horizontal_pos,
				 uint_t *vertical_pos)
{
  dc1394error_t err;
  quadlet_t value;
  
  if (!dc1394_is_video_mode_scalable(video_mode))
    return DC1394_INVALID_VIDEO_MODE;
  
  if (camera->iidc_version>=DC1394_IIDC_VERSION_1_30) {
    err = GetCameraFormat7Register(camera, video_mode, REG_CAMERA_FORMAT7_UNIT_POSITION_INQ, &value);
    DC1394_ERR_RTN(err, "Could not get unit position");
  }
  else {
    // if version is not 1.30, use the UNIT_SIZE_INQ register
    err = GetCameraFormat7Register(camera, video_mode, REG_CAMERA_FORMAT7_UNIT_SIZE_INQ, &value);
    DC1394_ERR_RTN(err, "Could not get unit size");
  }
  
  *horizontal_pos = (uint_t) (( value & 0xFFFF0000UL )>>16);
  *vertical_pos   = (uint_t) ( value & 0x0000FFFFUL );
  
  return err;
}

dc1394error_t
dc1394_format7_get_frame_interval(dc1394camera_t *camera,
				  dc1394video_mode_t video_mode, float *interval)
{   
  dc1394error_t err;
  quadlet_t value;
  
  if (!dc1394_is_video_mode_scalable(video_mode))
    return DC1394_INVALID_VIDEO_MODE;

  err=GetCameraFormat7Register(camera, video_mode, REG_CAMERA_FORMAT7_FRAME_INTERVAL_INQ, &value);
  DC1394_ERR_RTN(err, "Could not get frame interval");

  *interval=value;
  
  return err;
}   
    
dc1394error_t
dc1394_format7_get_data_depth(dc1394camera_t *camera,
			      dc1394video_mode_t video_mode, uint_t *data_depth)
{   
  dc1394error_t err;
  quadlet_t value;
  
  if (!dc1394_is_video_mode_scalable(video_mode))
    return DC1394_INVALID_VIDEO_MODE;
  
  err=GetCameraFormat7Register(camera, video_mode, REG_CAMERA_FORMAT7_DATA_DEPTH_INQ, &value);
  DC1394_ERR_RTN(err, "Could not get data depth");

  *data_depth=value >> 24;

  return err;
}   
    
dc1394error_t
dc1394_format7_get_color_filter(dc1394camera_t *camera,
				dc1394video_mode_t video_mode, dc1394color_filter_t *color_filter)
{   
  dc1394error_t err;
  quadlet_t value;

  if (!dc1394_is_video_mode_scalable(video_mode))
    return DC1394_INVALID_VIDEO_MODE;

  if (camera->iidc_version<DC1394_IIDC_VERSION_1_31)
    return DC1394_FUNCTION_NOT_SUPPORTED;
  
  err=GetCameraFormat7Register(camera, video_mode, REG_CAMERA_FORMAT7_COLOR_FILTER_ID, &value);
  DC1394_ERR_RTN(err, "Could not get color filter ID");

  *color_filter= (value >> 24)+DC1394_COLOR_FILTER_MIN;
  return err;
}   
     
dc1394error_t
dc1394_format7_set_color_filter(dc1394camera_t *camera,
				dc1394video_mode_t video_mode, dc1394color_filter_t color_filter)
{   
  dc1394error_t err;

  if (!dc1394_is_video_mode_scalable(video_mode))
    return DC1394_INVALID_VIDEO_MODE;
  
  if (camera->iidc_version<DC1394_IIDC_VERSION_1_31)
    return DC1394_FUNCTION_NOT_SUPPORTED;

  if ((color_filter<DC1394_COLOR_FILTER_MIN)||(color_filter>DC1394_COLOR_FILTER_MAX))
    return DC1394_INVALID_COLOR_FILTER;

  color_filter -= DC1394_COLOR_FILTER_MIN;
  color_filter <<= 24;

  err=SetCameraFormat7Register(camera, video_mode, REG_CAMERA_FORMAT7_COLOR_FILTER_ID,
			       color_filter);
  DC1394_ERR_RTN(err, "Could not set color filter ID");

  return err;
}   

dc1394error_t
dc1394_format7_get_mode_info(dc1394camera_t *camera,
			     dc1394video_mode_t video_mode, dc1394format7mode_t *f7_mode)
{
  dc1394error_t err=DC1394_SUCCESS;

  if (!dc1394_is_video_mode_scalable(video_mode))
    return DC1394_INVALID_VIDEO_MODE;

  if (f7_mode->present>0) { // check for mode presence before query
    err=dc1394_format7_get_max_image_size(camera,video_mode,&f7_mode->max_size_x,&f7_mode->max_size_y);
    DC1394_ERR_RTN(err,"Got a problem querying format7 max image size");
    err=dc1394_format7_get_unit_size(camera,video_mode,&f7_mode->unit_size_x,&f7_mode->unit_size_y);
    DC1394_ERR_RTN(err,"Got a problem querying format7 unit size");
    err=dc1394_format7_get_unit_position(camera,video_mode,&f7_mode->unit_pos_x,&f7_mode->unit_pos_y);
    if (err!=DC1394_SUCCESS) {
      //DC1394_ERR_RTN(err,"Got a problem querying format7 unit position");
      // unit position might not be supported, hence a softer check is implemented
      f7_mode->unit_pos_x=0;
      f7_mode->unit_pos_y=0;
    }

    err=dc1394_format7_get_image_position(camera,video_mode,&f7_mode->pos_x,&f7_mode->pos_y);
    DC1394_ERR_RTN(err,"Got a problem querying format7 image position");
    err=dc1394_format7_get_image_size(camera,video_mode,&f7_mode->size_x,&f7_mode->size_y);
    DC1394_ERR_RTN(err,"Got a problem querying format7 image size");
    err=dc1394_format7_get_byte_per_packet(camera,video_mode,&f7_mode->bpp);
    DC1394_ERR_RTN(err,"Got a problem querying format7 bytes per packet");
    
    if (f7_mode->bpp==0) {
      // sometimes a camera will not set the bpp register until a valid image size
      // has been set after boot. If BPP is zero, we therefor
      // try again after setting the image size to the maximum size.
      err=dc1394_format7_set_image_position(camera,video_mode,0,0);
      DC1394_ERR_RTN(err,"Got a problem setting format7 image position");
      err=dc1394_format7_set_image_size(camera,video_mode,f7_mode->max_size_x,f7_mode->max_size_y);
      DC1394_ERR_RTN(err,"Got a problem setting format7 image size");
      // maybe we should also force a color coding here.
      err=dc1394_format7_get_byte_per_packet(camera,video_mode,&f7_mode->bpp);
      DC1394_ERR_RTN(err,"Got a problem querying format7 bytes per packet");
    }
    
    err=dc1394_format7_get_packet_para(camera,video_mode,&f7_mode->min_bpp,&f7_mode->max_bpp);
    DC1394_ERR_RTN(err,"Got a problem querying format7 packet parameters");
    err=dc1394_format7_get_pixel_number(camera,video_mode,&f7_mode->pixnum);
    DC1394_ERR_RTN(err,"Got a problem querying format7 pixel number");
    err=dc1394_format7_get_total_bytes(camera,video_mode,&f7_mode->total_bytes);
    DC1394_ERR_RTN(err,"Got a problem querying format7 total bytes per frame");
    err=dc1394_format7_get_color_coding(camera,video_mode,&f7_mode->color_coding);
    DC1394_ERR_RTN(err,"Got a problem querying format7 color coding ID");
    err=dc1394_format7_get_color_codings(camera,video_mode,&f7_mode->color_codings);
    DC1394_ERR_RTN(err,"Got a problem querying format7 color coding");

    // WARNING: this requires to set the format7 mode!!
    if (camera->iidc_version >= DC1394_IIDC_VERSION_1_31) {
      err=dc1394_format7_get_color_filter(camera,video_mode,&f7_mode->color_filter);
      DC1394_ERR_RTN(err,"Got a problem querying format7 bayer pattern");
    }
    else {
      f7_mode->color_filter = 0;
    }

    //fprintf(stderr,"# color codings for mode %d: %d\n", video_mode, mode->color_codings.num);
  }

  return err;
}

dc1394error_t
dc1394_format7_get_modeset(dc1394camera_t *camera, dc1394format7modeset_t *info)
{
  dc1394error_t err;
  int i;
  dc1394video_modes_t modes;

  for (i=0;i<DC1394_VIDEO_MODE_FORMAT7_NUM;i++) {
    info->mode[i].present=0;
  }

  err=dc1394_video_get_supported_modes(camera, &modes);
  DC1394_ERR_RTN(err,"Could not query supported formats");

  // find a mode which is F7:
  for (i=0;i<modes.num;i++) {
    if (dc1394_is_video_mode_scalable(modes.modes[i])) {
      info->mode[modes.modes[i]-DC1394_VIDEO_MODE_FORMAT7_MIN].present= 1;
      dc1394_format7_get_mode_info(camera, modes.modes[i], &info->mode[modes.modes[i]-DC1394_VIDEO_MODE_FORMAT7_MIN]);
      //fprintf(stderr,"# color codings for mode %d: %d\n", modes.modes[i], info->mode[modes.modes[i]-DC1394_VIDEO_MODE_FORMAT7_MIN].color_codings.num);
    }
  }

  return err;
}