gstreamer/sys/qcam/qcam-lib.c

/* qcam-lib.c -- Library for programming with the Connectix QuickCam.
 * See the included documentation for usage instructions and details
 * of the protocol involved. */


/* Version 0.5, August 4, 1996 */
/* Version 0.7, August 27, 1996 */
/* Version 0.9, November 17, 1996 */


/******************************************************************

Copyright (C) 1996 by Scott Laird

Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:

The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL SCOTT LAIRD BE LIABLE FOR ANY CLAIM, DAMAGES OR
OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.

******************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

#include <unistd.h>

#include <assert.h>

#include "qcam.h"
#include "qcam-os.h"
#include "qcam-os.c"

/* Prototypes for static functions.  Externally visible functions
 * should be prototyped in qcam.h */

static int qc_waithand(const struct qcam *q, int val);
static int qc_command(const struct qcam *q, int command);
static int qc_readparam(const struct qcam *q);
static int qc_setscanmode(struct qcam *q);
static int qc_readbytes(const struct qcam *q, char buffer[]);

/* The next several functions are used for controlling the qcam
 * structure.  They aren't used inside this library, but they should
 * provide a clean interface for external programs.*/

/* Gets/sets the brightness. */

int qc_getbrightness(const struct qcam *q)
{
  return q->brightness;
}

int qc_setbrightness(struct qcam *q, int val)
{
  if (val >= 0 && val <= 255) {
    q->brightness=val;
    return 0;
  }
  return 1;
}


/* Gets/sets the contrast */

int qc_getcontrast(const struct qcam *q)
{
  return q->contrast;
}

int qc_setcontrast(struct qcam *q, int val)
{
  if (val >= 0 && val <= 255) {
    q->contrast=val;
    return 0;
  }
  return 1;
}


/* Gets/sets the white balance */

int qc_getwhitebal(const struct qcam *q)
{
  return q->whitebal;
}

int qc_setwhitebal(struct qcam *q, int val)
{
  if (val >= 0 && val <= 255) {
    q->whitebal=val;
    return 0;
  }
  return 1;
}


/* Gets/sets the resolution */

void qc_getresolution(const struct qcam *q, int *x, int *y)
{
  *x=q->width;
  *y=q->height;
}

int qc_setresolution(struct qcam *q, int x, int y)
{
  if (x >= 0 && x <= 336 && y >= 0 && y <= 243) {
    q->width=x;
    q->height=y;
    return 0;
  }
  return 1;
}

int qc_getheight(const struct qcam *q)
{
  return q->height;
}

int qc_setheight(struct qcam *q, int y)
{
  if (y >= 0 && y <= 243) {
    q->height=y;
    return 0;
  }
  return 1;
}

int qc_getwidth(const struct qcam *q)
{
  return q->width;
}

int qc_setwidth(struct qcam *q, int x)
{
  if (x >= 0 && x <= 336) {
    q->width=x;
    return 0;
  }
  return 1;
}

/* Gets/sets the bit depth */

int qc_getbitdepth(const struct qcam *q)
{
  return q->bpp;
}

int qc_setbitdepth(struct qcam *q, int val)
{
  if (val == 4 || val == 6) {
    q->bpp=val;
    return qc_setscanmode(q);
  }
  return 1;
}

int qc_gettop(const struct qcam *q)
{
  return q->top;
}

int qc_settop(struct qcam *q, int val)
{
  if (val >= 1 && val <= 243) {
    q->top = val;
    return 0;
  }
  return 1;
}

int qc_getleft(const struct qcam *q)
{
  return q->left;
}

int qc_setleft(struct qcam *q, int val)
{
  if (val % 2 == 0 && val >= 2 && val <= 336) {
    q->left = val;
    return 0;
  }
  return 1;
}

int qc_gettransfer_scale(const struct qcam *q)
{
  return q->transfer_scale;
}

int qc_settransfer_scale(struct qcam *q, int val)
{
  if (val == 1 || val == 2 || val == 4) {
    q->transfer_scale = val;
    return qc_setscanmode(q);
  }
  return 1;
}

int
qc_calibrate(struct qcam *q)
/* bugfix by Hanno Mueller hmueller@kabel.de, Mai 21 96 */
/* The white balance is an individiual value for each */
/* quickcam. Run calibration once, write the value down */
/* and put it in your qcam.conf file. You won't need to */
/* recalibrate your camera again. */
{
  int value;
#ifdef DEBUG
  int count = 0;
#endif

  qc_command(q, 27); /* AutoAdjustOffset */
  qc_command(q, 0);  /* Dummy Parameter, ignored by the camera */

  /* GetOffset (33) will read 255 until autocalibration */
  /* is finished. After that, a value of 1-254 will be */
  /* returned. */

  do {
    qc_command(q, 33); value = qc_readparam(q);
#ifdef DEBUG
    count++;
#endif
  } while (value == 0xff);

  q->whitebal = value;

#ifdef DEBUG
  fprintf(stderr, "%d loops to calibrate\n", count);
  fprintf(stderr, "Calibrated to %d\n", value);
#endif

  return value;
}

int
qc_forceunidir(struct qcam *q)
{
  q->port_mode = (q->port_mode & ~QC_FORCE_MASK) | QC_FORCE_UNIDIR;
  return 0;
}


/* Initialize the QuickCam driver control structure.  This is where
 * defaults are set for people who don't have a config file.*/
struct qcam *
qc_init(void)
{
  struct qcam *q;

  q=malloc(sizeof(struct qcam));

  q->port=0; /* Port 0 == Autoprobe */
  q->port_mode=(QC_ANY | QC_NOTSET);
  q->width=160;
  q->height=120;
  q->bpp=4;
  q->transfer_scale = 2;
  q->contrast=104;
  q->brightness=150;
  q->whitebal=150;
  q->top = 1;
  q->left = 14;
  q->mode = -1;
  q->fd=-1; /* added initialization of fd member
             * BTW, there doesn't seem to be a place to close this fd...
             * I think we need a qc_free function.
             * - Dave Plonka (plonka@carroll1.cc.edu)
             */

  return q;
}


/* qc_open enables access to the port specified in q->port.  It takes
 * care of locking and enabling I/O port access by calling the
 * appropriate routines.
 *
 * Returns 0 for success, 1 for opening error, 2 for locking error,
 * and 3 for qcam not found */

int qc_open(struct qcam *q)
{
  if(q->port==0)
    if(qc_probe(q)) {
      fprintf(stderr,"Qcam not found\n");
      return 3;
    }

  if(qc_lock(q)) {
    fprintf(stderr,"Cannot lock qcam.\n");
    return 2;
  }

  if(enable_ports(q)) {
    fprintf(stderr,"Cannot open QuickCam -- permission denied.");
    return 1;
  } else {
    return 0;
  }
}


/* qc_close closes and unlocks the driver.  You *need* to call this,
 * or lockfiles will be left behind and everything will be screwed. */

int qc_close(struct qcam *q)
{
  qc_unlock(q);

  disable_ports(q);
  return 0;
}


/* qc_command is probably a bit of a misnomer -- it's used to send
 * bytes *to* the camera.  Generally, these bytes are either commands
 * or arguments to commands, so the name fits, but it still bugs me a
 * bit.  See the documentation for a list of commands. */

static int qc_command(const struct qcam *q, int command)
{
  int n1, n2;
  int cmd;

  write_lpdata(q, command);
  write_lpcontrol(q,6);

  n1 = qc_waithand(q,1);

  write_lpcontrol(q,0xe);
  n2 = qc_waithand(q,0);

  cmd = (n1 & 0xf0) | ((n2 & 0xf0) >> 4);
#ifdef DEBUG
  if (cmd != command) {
    fprintf(stderr, "Command 0x%02x sent, 0x%02x echoed", command, cmd);
    n2 = read_lpstatus(q);
    cmd = (n1 & 0xf0) | ((n2 & 0xf0) >> 4);
    if (cmd != command) fprintf(stderr, " (re-read does not help)\n");
    else fprintf(stderr, " (fixed on re-read)\n");
  }
#endif
  return cmd;
}

static int
qc_readparam(const struct qcam *q)
{
  int n1, n2;
  int cmd;

  write_lpcontrol(q,6);
  n1 = qc_waithand(q,1);

  write_lpcontrol(q,0xe);
  n2 = qc_waithand(q,0);

  cmd = (n1 & 0xf0) | ((n2 & 0xf0) >> 4);
  return cmd;
}

/* qc_waithand busy-waits for a handshake signal from the QuickCam.
 * Almost all communication with the camera requires handshaking. */

static int qc_waithand(const struct qcam *q, int val)
{
  int status;

  if (val)
    while(! ((status = read_lpstatus(q))&8))
	;
  else
    while (((status = read_lpstatus(q))&8))
	;

  return status;
}

/* Waithand2 is used when the qcam is in bidirectional mode, and the
 * handshaking signal is CamRdy2 (bit 0 of data reg) instead of CamRdy1
 * (bit 3 of status register).  It also returns the last value read,
 * since this data is useful. */

static unsigned int
qc_waithand2(const struct qcam *q, int val)
{
  unsigned int status;
  do {
    status = read_lpdata(q);
  } while ( (status & 1) != val);

  return status;
}


/* Try to detect a QuickCam.  It appears to flash the upper 4 bits of
   the status register at 5-10 Hz.  This is only used in the autoprobe
   code.  Be aware that this isn't the way Connectix detects the
   camera (they send a reset and try to handshake), but this should be
   almost completely safe, while their method screws up my printer if
   I plug it in before the camera. */

int qc_detect(const struct qcam *q)
{
  int reg,lastreg;
  int count=0;
  int i;

  lastreg=reg=read_lpstatus(q)&0xf0;

  for(i=0;i<30;i++) {
    reg=read_lpstatus(q)&0xf0;
    if(reg!=lastreg) count++;
    lastreg=reg;
    usleep(10000);
  }

  /* Be liberal in what you accept...  */

  if(count>3&&count<15)
    return 1; /* found */
  else 
    return 0; /* not found */
}


/* Reset the QuickCam.  This uses the same sequence the Windows
 * QuickPic program uses.  Someone with a bi-directional port should
 * check that bi-directional mode is detected right, and then
 * implement bi-directional mode in qc_readbyte(). */

void qc_reset(struct qcam *q)
{
  switch (q->port_mode & QC_FORCE_MASK)
  {
    case QC_FORCE_UNIDIR:
      q->port_mode = (q->port_mode & ~QC_MODE_MASK) | QC_UNIDIR;
      break;

    case QC_FORCE_BIDIR:
      q->port_mode = (q->port_mode & ~QC_MODE_MASK) | QC_BIDIR;
      break;

    case QC_ANY:
      write_lpcontrol(q,0x20);
      write_lpdata(q,0x75);

      if (read_lpdata(q) != 0x75) {
	q->port_mode = (q->port_mode & ~QC_MODE_MASK) | QC_BIDIR;
      } else {
	q->port_mode = (q->port_mode & ~QC_MODE_MASK) | QC_UNIDIR;
      }
      break;

    case QC_FORCE_SERIAL:
    default:
      fprintf(stderr, "Illegal port_mode %x\n", q->port_mode);
      break;
  }

  /* usleep(250);*/
  write_lpcontrol(q,0xb);
  usleep(250);
  write_lpcontrol(q,0xe);
  (void)qc_setscanmode(q); /* in case port_mode changed */
}


/* Decide which scan mode to use.  There's no real requirement that
 * the scanmode match the resolution in q->height and q-> width -- the
 * camera takes the picture at the resolution specified in the
 * "scanmode" and then returns the image at the resolution specified
 * with the resolution commands.  If the scan is bigger than the
 * requested resolution, the upper-left hand corner of the scan is
 * returned.  If the scan is smaller, then the rest of the image
 * returned contains garbage. */

static int qc_setscanmode(struct qcam *q)
{
  switch (q->transfer_scale) {
    case 1: q->mode = 0; break;
    case 2: q->mode = 4; break;
    case 4: q->mode = 8; break;
    default: return 1;
  }

  switch (q->bpp) {
  case 4: break;
  case 6: q->mode+=2; break;
  default:
    fprintf(stderr,"Error: Unsupported bit depth\n");
    return 1;
  }

  switch (q->port_mode & QC_MODE_MASK) {
  case QC_BIDIR: q->mode += 1; break;
  case QC_NOTSET:
  case QC_UNIDIR: break;
  default: return 1;
  }
  return 0;
}


/* Reset the QuickCam and program for brightness, contrast,
 * white-balance, and resolution. */

void qc_set(struct qcam *q)
{
  int val;
  int val2;

  qc_reset(q);

  /* Set the brightness.  Yes, this is repetitive, but it works.
   * Shorter versions seem to fail subtly.  Feel free to try :-). */
  /* I think the problem was in qc_command, not here -- bls */
  qc_command(q,0xb);
  qc_command(q,q->brightness);

  val = q->height / q->transfer_scale;
  qc_command(q,0x11); qc_command(q, val);
  if ((q->port_mode & QC_MODE_MASK) == QC_UNIDIR && q->bpp == 6) {
    /* The normal "transfers per line" calculation doesn't seem to work
	as expected here (and yet it works fine in qc_scan).  No idea
	why this case is the odd man out.  Fortunately, Laird's original
	working version gives me a good way to guess at working values.
	-- bls */
    val = q->width;
    val2 = q->transfer_scale * 4;
  } else {
    val = q->width * q->bpp;
    val2 = (((q->port_mode & QC_MODE_MASK) == QC_BIDIR)?24:8) *
	q->transfer_scale;
  }
  val = (val + val2 - 1) / val2;
  qc_command(q,0x13); qc_command(q, val);

  /* I still don't know what these do! */
  /* They're setting top and left -- bls */
  qc_command(q,0xd); qc_command(q,q->top);
  qc_command(q,0xf); qc_command(q,q->left/2);

  qc_command(q,0x19); qc_command(q,q->contrast);
  qc_command(q,0x1f); qc_command(q,q->whitebal);
}


/* Qc_readbytes reads some bytes from the QC and puts them in
   the supplied buffer.  It returns the number of bytes read,
   or -1 on error. */

static int
__inline__
qc_readbytes(const struct qcam *q, char buffer[])
{
  int ret;
  unsigned int hi, lo;
  unsigned int hi2, lo2;
  static unsigned int saved_bits;
  static int state = 0;

  if (buffer == NULL) {
    state = 0;
    return 0; 
  }

  switch (q->port_mode & QC_MODE_MASK) {
  case QC_BIDIR:  /* Bi-directional Port */
    write_lpcontrol(q, 0x26);
    lo = (qc_waithand2(q, 1) >> 1);
    hi = (read_lpstatus(q) >> 3) & 0x1f;
    write_lpcontrol(q, 0x2e);
    lo2 = (qc_waithand2(q, 0) >> 1);
    hi2 = (read_lpstatus(q) >> 3) & 0x1f;
    switch (q->bpp) {
      case 4:
	buffer[0] = lo & 0xf;
	buffer[1] = ((lo & 0x70) >> 4) | ((hi & 1) << 3);
	buffer[2] = (hi & 0x1e) >> 1;
	buffer[3] = lo2 & 0xf;
	buffer[4] = ((lo2 & 0x70) >> 4) | ((hi2 & 1) << 3);
	buffer[5] = (hi2 & 0x1e) >> 1;
	ret = 6;
	break;
      case 6:
	buffer[0] = lo & 0x3f;
	buffer[1] = ((lo & 0x40) >> 6) | (hi << 1);
	buffer[2] = lo2 & 0x3f;
	buffer[3] = ((lo2 & 0x40) >> 6) | (hi2 << 1);
	ret = 4;
	break;
      default:
	fprintf(stderr, "Bad bidir pixel depth %d\n", q->bpp);
	ret = -1;
	break;
    }
    break;

  case QC_UNIDIR:  /* Unidirectional Port */
    write_lpcontrol(q,6);
    lo = (qc_waithand(q,1) & 0xf0) >> 4;
    write_lpcontrol(q,0xe);
    hi = (qc_waithand(q,0) & 0xf0) >> 4;

    switch (q->bpp) {
      case 4:
	buffer[0] = lo;
	buffer[1] = hi;
	ret = 2;
	break;
      case 6:
	switch (state) {
	  case 0:
	    buffer[0] = (lo << 2) | ((hi & 0xc) >> 2);
	    saved_bits = (hi & 3) << 4;
	    state = 1; ret = 1; break;
	  case 1:
	    buffer[0] = lo | saved_bits;
	    saved_bits = hi << 2;
	    state = 2; ret = 1; break;
	  case 2:
	    buffer[0] = ((lo & 0xc) >> 2) | saved_bits;
	    buffer[1] = ((lo & 3) << 4)  | hi;
	    state = 0; ret = 2; break;
	  default:
	    fprintf(stderr, "Unidir 6-bit state %d?\n", state);
	    ret = -1;
	    break;
	}
	break;
      default:
	fprintf(stderr, "Bad unidir pixel depth %d\n", q->bpp);
	ret = -1;
	break;
    }
    break;
  case QC_SERIAL: /* Serial Interface.  Just in case.*/
  default:
    fprintf(stderr,"Mode %x not supported\n",q->port_mode);
    ret=-1;
    break;
  }
  return ret;
}

/* Read a scan from the QC.  This takes the qcam structure and
 * requests a scan from the camera.  It sends the correct instructions
 * to the camera and then reads back the correct number of bytes.  In
 * previous versions of this routine the return structure contained
 * the raw output from the camera, and there was a 'qc_convertscan'
 * function that converted that to a useful format.  In version 0.3 I
 * rolled qc_convertscan into qc_scan and now I only return the
 * converted scan.  The format is just an one-dimensional array of
 * characters, one for each pixel, with 0=black up to n=white, where
 * n=2^(bit depth)-1.  Ask me for more details if you don't understand
 * this. */

scanbuf *qc_scan(const struct qcam *q)
{
  unsigned char *ret;
  int i, j, k;
  int bytes;
  int linestotrans, transperline;
  int divisor;
  int pixels_per_line;
  int pixels_read;
  char buffer[6];
  char invert;

  if (q->mode != -1) {
    qc_command(q, 0x7);
    qc_command(q, q->mode);
  } else {
    struct qcam bogus_cam;
    /* We're going through these odd hoops to retain the "const"
	qualification on q.  We can't do a qc_setscanmode directly on q,
	so we copy it, do a setscanmode on that, and pass in the newly
	computed mode. -- bls 11/21/96
    */

#ifdef DEBUG
    fprintf(stderr, "Warning!  qc->mode not set!\n");
#endif
    bogus_cam = *q;
    (void)qc_setscanmode(&bogus_cam);
    qc_command(q, 0x7);
    qc_command(q, bogus_cam.mode);
  }

  if ((q->port_mode & QC_MODE_MASK) == QC_BIDIR) {
    write_lpcontrol(q, 0x2e); /* turn port around */
    write_lpcontrol(q, 0x26);
    (void) qc_waithand(q, 1);
    write_lpcontrol(q, 0x2e);
    (void) qc_waithand(q, 0);
  }

  /* strange -- should be 15:63 below, but 4bpp is odd */
  invert = (q->bpp == 4) ? 16 : 63;

  linestotrans = q->height / q->transfer_scale;
  pixels_per_line = q->width / q->transfer_scale;
  transperline = q->width * q->bpp;
  divisor = (((q->port_mode & QC_MODE_MASK) == QC_BIDIR)?24:8) *
	q->transfer_scale;
  transperline = (transperline + divisor - 1) / divisor;

  ret = malloc(linestotrans * pixels_per_line);
  assert(ret);

#ifdef DEBUG
  fprintf(stderr, "%s %d bpp\n%d lines of %d transfers each\n",
	((q->port_mode & QC_MODE_MASK) == QC_BIDIR)?"Bidir":"Unidir",
	q->bpp, linestotrans, transperline);
#endif

  for (i = 0; i < linestotrans; i++) {
    for (pixels_read = j = 0; j < transperline; j++) {
      bytes = qc_readbytes(q, buffer);
      assert(bytes > 0);
      for (k = 0; k < bytes && (pixels_read + k) < pixels_per_line; k++) {
	assert (buffer[k] <= invert);
	assert (buffer[k] >= 0);
	if (buffer[k] == 0 && invert == 16) {
	  /* 4bpp is odd (again) -- inverter is 16, not 15, but output
	     must be 0-15 -- bls */
	  buffer[k] = 16;
	}
	ret[i*pixels_per_line + pixels_read + k] = invert - buffer[k];
      }
      pixels_read += bytes;
    }
    (void) qc_readbytes(q, 0); /* reset state machine */
  }

  if ((q->port_mode & QC_MODE_MASK) == QC_BIDIR) {
    write_lpcontrol(q, 2);
    write_lpcontrol(q, 6);
    usleep(3);
    write_lpcontrol(q, 0xe);
  }

  return ret;
}


void
qc_dump(const struct qcam *q, char *fname)
{
  FILE *fp;
  time_t t;

  if ((fp = fopen(fname, "w")) == 0)
  {
    fprintf(stderr, "Error: cannot open %s\n", fname);
    return;
  }

  fprintf(fp, "# Version 0.9\n");
  time(&t);
  fprintf(fp, "# Created %s", ctime(&t));
  fprintf(fp, "Width %d\nHeight %d\n", q->width, q->height);
  fprintf(fp, "Top %d\nLeft %d\n", q->top, q->left);
  fprintf(fp, "Bpp %d\nContrast %d\n", q->bpp, q->contrast);
  fprintf(fp, "Brightness %d\nWhitebal %d\n", q->brightness, q->whitebal);
  fprintf(fp, "Port 0x%x\nScale %d\n", q->port, q->transfer_scale);
  fclose(fp);
}