libv4lconvert.c

trident tm5600的linux驱动

	break;
      default:
	tinyjpeg_set_components(data->jdec, components, 3);
	result = tinyjpeg_decode(data->jdec, TINYJPEG_FMT_YUV420P);
	break;
      }

      if (result) {
	/* Pixart webcam's seem to regulary generate corrupt frames, which
	   are best thrown away to avoid flashes in the video stream. Tell
	   the upper layer this is an intermediate fault and it should try
	   again with a new buffer by setting errno to EAGAIN */
	if (src_fmt->fmt.pix.pixelformat == V4L2_PIX_FMT_PJPG) {
	  V4LCONVERT_ERR("Error decompressing JPEG: %s",
	    tinyjpeg_get_errorstring(data->jdec));
	  errno = EAGAIN;
	  return -1;
	} else {
	/* If the JPEG header checked out ok and we get an error during actual
	   decompression, log the error, but don't return an errorcode to the
	   application, so that the user gets what we managed to decompress */
	  fprintf(stderr, "libv4lconvert: Error decompressing JPEG: %s",
	    tinyjpeg_get_errorstring(data->jdec));
	}
      }
      break;

    case V4L2_PIX_FMT_SBGGR8:
    case V4L2_PIX_FMT_SGBRG8:
    case V4L2_PIX_FMT_SGRBG8:
    case V4L2_PIX_FMT_SRGGB8:
      switch (dest_fmt->fmt.pix.pixelformat) {
      case V4L2_PIX_FMT_RGB24:
	v4lconvert_bayer_to_rgb24(src, dest, dest_fmt->fmt.pix.width,
		    dest_fmt->fmt.pix.height, src_fmt->fmt.pix.pixelformat);
	break;
      case V4L2_PIX_FMT_BGR24:
	v4lconvert_bayer_to_bgr24(src, dest, dest_fmt->fmt.pix.width,
		    dest_fmt->fmt.pix.height, src_fmt->fmt.pix.pixelformat);
	break;
      default:
	v4lconvert_bayer_to_yuv420(src, dest, dest_fmt->fmt.pix.width,
		    dest_fmt->fmt.pix.height, src_fmt->fmt.pix.pixelformat);
	break;
      }
      break;

    /* YUYV line by line formats */
    case V4L2_PIX_FMT_SPCA501:
    case V4L2_PIX_FMT_SPCA505:
    case V4L2_PIX_FMT_SPCA508:
    {
      unsigned char tmpbuf[dest_fmt->fmt.pix.width * dest_fmt->fmt.pix.height *
			   3 / 2];
      unsigned char *my_dst = (dest_fmt->fmt.pix.pixelformat !=
			       V4L2_PIX_FMT_YUV420) ? tmpbuf : dest;

      switch (src_fmt->fmt.pix.pixelformat) {
	case V4L2_PIX_FMT_SPCA501:
	  v4lconvert_spca501_to_yuv420(src, my_dst, dest_fmt->fmt.pix.width,
				       dest_fmt->fmt.pix.height);
	  break;
	case V4L2_PIX_FMT_SPCA505:
	  v4lconvert_spca505_to_yuv420(src, my_dst, dest_fmt->fmt.pix.width,
				       dest_fmt->fmt.pix.height);
	  break;
	case V4L2_PIX_FMT_SPCA508:
	  v4lconvert_spca508_to_yuv420(src, my_dst, dest_fmt->fmt.pix.width,
				       dest_fmt->fmt.pix.height);
	  break;
      }

      switch (dest_fmt->fmt.pix.pixelformat) {
      case V4L2_PIX_FMT_RGB24:
	v4lconvert_yuv420_to_rgb24(tmpbuf, dest, dest_fmt->fmt.pix.width,
				   dest_fmt->fmt.pix.height);
	break;
      case V4L2_PIX_FMT_BGR24:
	v4lconvert_yuv420_to_bgr24(tmpbuf, dest, dest_fmt->fmt.pix.width,
				   dest_fmt->fmt.pix.height);
	break;
      }
      break;
    }

    /* compressed bayer formats */
    case V4L2_PIX_FMT_SPCA561:
    case V4L2_PIX_FMT_SN9C10X:
    case V4L2_PIX_FMT_PAC207:
    {
      unsigned char tmpbuf[dest_fmt->fmt.pix.width*dest_fmt->fmt.pix.height];
      unsigned int bayer_fmt = 0;

      switch (src_fmt->fmt.pix.pixelformat) {
	case V4L2_PIX_FMT_SPCA561:
	  v4lconvert_decode_spca561(src, tmpbuf, dest_fmt->fmt.pix.width,
				    dest_fmt->fmt.pix.height);
	  bayer_fmt = V4L2_PIX_FMT_SGBRG8;
	  break;
	case V4L2_PIX_FMT_SN9C10X:
	  v4lconvert_decode_sn9c10x(src, tmpbuf, dest_fmt->fmt.pix.width,
				    dest_fmt->fmt.pix.height);
	  bayer_fmt = V4L2_PIX_FMT_SBGGR8;
	  break;
	case V4L2_PIX_FMT_PAC207:
	  v4lconvert_decode_pac207(src, tmpbuf, dest_fmt->fmt.pix.width,
				    dest_fmt->fmt.pix.height);
	  bayer_fmt = V4L2_PIX_FMT_SBGGR8;
	  break;
      }

      switch (dest_fmt->fmt.pix.pixelformat) {
      case V4L2_PIX_FMT_RGB24:
	v4lconvert_bayer_to_rgb24(tmpbuf, dest, dest_fmt->fmt.pix.width,
		    dest_fmt->fmt.pix.height, bayer_fmt);
	break;
      case V4L2_PIX_FMT_BGR24:
	v4lconvert_bayer_to_bgr24(tmpbuf, dest, dest_fmt->fmt.pix.width,
		    dest_fmt->fmt.pix.height, bayer_fmt);
	break;
      default:
	v4lconvert_bayer_to_yuv420(tmpbuf, dest, dest_fmt->fmt.pix.width,
		    dest_fmt->fmt.pix.height, bayer_fmt);
	break;
      }
      break;
    }

    case V4L2_PIX_FMT_RGB24:
      switch (dest_fmt->fmt.pix.pixelformat) {
      case V4L2_PIX_FMT_BGR24:
	v4lconvert_swap_rgb(src, dest, dest_fmt->fmt.pix.width,
			    dest_fmt->fmt.pix.height);
	break;
      case V4L2_PIX_FMT_YUV420:
	printf("FIXME add rgb24 -> yuv420 conversion\n");
	break;
      }
      break;
    case V4L2_PIX_FMT_BGR24:
      switch (dest_fmt->fmt.pix.pixelformat) {
      case V4L2_PIX_FMT_RGB24:
	v4lconvert_swap_rgb(src, dest, dest_fmt->fmt.pix.width,
			    dest_fmt->fmt.pix.height);
	break;
      case V4L2_PIX_FMT_YUV420:
	printf("FIXME add bgr24 -> yuv420 conversion\n");
	break;
      }
      break;

    case V4L2_PIX_FMT_YUV420:
      switch (dest_fmt->fmt.pix.pixelformat) {
      case V4L2_PIX_FMT_RGB24:
	v4lconvert_yuv420_to_rgb24(src, dest, dest_fmt->fmt.pix.width,
				   dest_fmt->fmt.pix.height);
	break;
      case V4L2_PIX_FMT_BGR24:
	v4lconvert_yuv420_to_bgr24(src, dest, dest_fmt->fmt.pix.width,
				   dest_fmt->fmt.pix.height);
	break;
      }
      break;

    case V4L2_PIX_FMT_YUYV:
      switch (dest_fmt->fmt.pix.pixelformat) {
      case V4L2_PIX_FMT_RGB24:
	v4lconvert_yuyv_to_rgb24(src, dest, dest_fmt->fmt.pix.width,
				   dest_fmt->fmt.pix.height);
	break;
      case V4L2_PIX_FMT_BGR24:
	v4lconvert_yuyv_to_bgr24(src, dest, dest_fmt->fmt.pix.width,
				   dest_fmt->fmt.pix.height);
	break;
      default:
	v4lconvert_yuyv_to_yuv420(src, dest, dest_fmt->fmt.pix.width,
		    dest_fmt->fmt.pix.height);
	break;
      }
      break;

    case V4L2_PIX_FMT_YVYU:
      switch (dest_fmt->fmt.pix.pixelformat) {
      case V4L2_PIX_FMT_RGB24:
	v4lconvert_yvyu_to_rgb24(src, dest, dest_fmt->fmt.pix.width,
				   dest_fmt->fmt.pix.height);
	break;
      case V4L2_PIX_FMT_BGR24:
	v4lconvert_yvyu_to_bgr24(src, dest, dest_fmt->fmt.pix.width,
				   dest_fmt->fmt.pix.height);
	break;
      default:
	v4lconvert_yvyu_to_yuv420(src, dest, dest_fmt->fmt.pix.width,
		    dest_fmt->fmt.pix.height);
	break;
      }
      break;

    default:
      V4LCONVERT_ERR("Unknown src format in conversion\n");
      errno = EINVAL;
      return -1;
  }

  /* Note when rotating dest is our temporary buffer to which our conversion
     was done and _dest is the real dest! If the formats are identical no
     conversion has been done! */
  if (rotate && dest_fmt->fmt.pix.pixelformat == src_fmt->fmt.pix.pixelformat)
    dest = src;

  switch (rotate) {
  case 0:
    break;
  case 90:
    switch (dest_fmt->fmt.pix.pixelformat) {
      case V4L2_PIX_FMT_RGB24:
      case V4L2_PIX_FMT_BGR24:
	v4lconvert_rotate90_rgbbgr24(dest, _dest, dest_fmt->fmt.pix.width,
				 dest_fmt->fmt.pix.height);
	break;
      case V4L2_PIX_FMT_YUV420:
	v4lconvert_rotate90_yuv420(dest, _dest, dest_fmt->fmt.pix.width,
			       dest_fmt->fmt.pix.height);
	break;
    }
    break;
  case 180:
    switch (dest_fmt->fmt.pix.pixelformat) {
      case V4L2_PIX_FMT_RGB24:
      case V4L2_PIX_FMT_BGR24:
	v4lconvert_rotate180_rgbbgr24(dest, _dest, dest_fmt->fmt.pix.width,
				 dest_fmt->fmt.pix.height);
	break;
      case V4L2_PIX_FMT_YUV420:
	v4lconvert_rotate180_yuv420(dest, _dest, dest_fmt->fmt.pix.width,
			       dest_fmt->fmt.pix.height);
	break;
    }
    break;
  default:
    printf("FIXME add %d degrees rotation\n", rotate);
  }

  return needed;
}

const char *v4lconvert_get_error_message(struct v4lconvert_data *data)
{
  return data->error_msg;
}

static void v4lconvert_get_framesizes(struct v4lconvert_data *data,
  unsigned int pixelformat)
{
  int i, j, match;
  struct v4l2_frmsizeenum frmsize = { .pixel_format = pixelformat };

  for (i = 0; ; i++) {
    frmsize.index = i;
    if (syscall(SYS_ioctl, data->fd, VIDIOC_ENUM_FRAMESIZES, &frmsize))
      break;

    /* We got a framesize, check we don't have the same one already */
    match = 0;
    for (j = 0; j < data->no_framesizes && !match; j++) {
      if (frmsize.type != data->framesizes[j].type)
	continue;

      switch(frmsize.type) {
	case V4L2_FRMSIZE_TYPE_DISCRETE:
	  if(!memcmp(&frmsize.discrete, &data->framesizes[j].discrete,
		     sizeof(frmsize.discrete)))
	    match = 1;
	  break;
	case V4L2_FRMSIZE_TYPE_CONTINUOUS:
	case V4L2_FRMSIZE_TYPE_STEPWISE:
	  if(!memcmp(&frmsize.stepwise, &data->framesizes[j].stepwise,
		     sizeof(frmsize.stepwise)))
	    match = 1;
	  break;
      }
    }
    /* Add this framesize if it is not already in our list */
    if (!match) {
      if (data->no_framesizes == V4LCONVERT_MAX_FRAMESIZES) {
	fprintf(stderr,
	  "libv4lconvert: warning more framesizes then I can handle!\n");
	return;
      }
      data->framesizes[data->no_framesizes].type = frmsize.type;
      switch(frmsize.type) {
	case V4L2_FRMSIZE_TYPE_DISCRETE:
	  data->framesizes[data->no_framesizes].discrete = frmsize.discrete;
	  break;
	case V4L2_FRMSIZE_TYPE_CONTINUOUS:
	case V4L2_FRMSIZE_TYPE_STEPWISE:
	  data->framesizes[data->no_framesizes].stepwise = frmsize.stepwise;
	  break;
      }
      data->no_framesizes++;
    }
  }
}

int v4lconvert_enum_framesizes(struct v4lconvert_data *data,
  struct v4l2_frmsizeenum *frmsize)
{
  if (!v4lconvert_supported_dst_format(frmsize->pixel_format))
    return syscall(SYS_ioctl, data->fd, VIDIOC_ENUM_FRAMESIZES, frmsize);

  if (frmsize->index >= data->no_framesizes) {
    errno = EINVAL;
    return -1;
  }

  frmsize->type = data->framesizes[frmsize->index].type;
  switch(frmsize->type) {
    case V4L2_FRMSIZE_TYPE_DISCRETE:
      frmsize->discrete = data->framesizes[frmsize->index].discrete;
      break;
    case V4L2_FRMSIZE_TYPE_CONTINUOUS:
    case V4L2_FRMSIZE_TYPE_STEPWISE:
      frmsize->stepwise = data->framesizes[frmsize->index].stepwise;
      break;
  }

  return 0;
}

int v4lconvert_enum_frameintervals(struct v4lconvert_data *data,
  struct v4l2_frmivalenum *frmival)
{
  int res;
  struct v4l2_format src_fmt, dest_fmt;

  if (!v4lconvert_supported_dst_format(frmival->pixel_format))
    return syscall(SYS_ioctl, data->fd, VIDIOC_ENUM_FRAMEINTERVALS, frmival);

  /* Check which format we will be using to convert to frmival->pixel_format */
  memset(&dest_fmt, 0, sizeof(dest_fmt));
  dest_fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  dest_fmt.fmt.pix.pixelformat = frmival->pixel_format;
  dest_fmt.fmt.pix.width = frmival->width;
  dest_fmt.fmt.pix.height = frmival->height;
  if ((res = v4lconvert_try_format(data, &dest_fmt, &src_fmt)))
    return res;

  /* Check the requested format is supported exactly as requested */
  if (dest_fmt.fmt.pix.pixelformat != frmival->pixel_format ||
      dest_fmt.fmt.pix.width  != frmival->width ||
      dest_fmt.fmt.pix.height != frmival->height) {
    errno = EINVAL;
    return -1;
  }

  /* Enumerate the frameintervals of the source format we will be using */
  frmival->pixel_format = src_fmt.fmt.pix.pixelformat;
  frmival->width = src_fmt.fmt.pix.width;
  frmival->height = src_fmt.fmt.pix.height;
  res = syscall(SYS_ioctl, data->fd, VIDIOC_ENUM_FRAMEINTERVALS, frmival);

  /* Restore the requested format in the frmival struct */
  frmival->pixel_format = dest_fmt.fmt.pix.pixelformat;
  frmival->width = dest_fmt.fmt.pix.width;
  frmival->height = dest_fmt.fmt.pix.height;

  return res;
}