From 7a778ee4b7ec09a1f5b2185c9cceee3910dfbdf2 Mon Sep 17 00:00:00 2001
From: Thomas Vander Stichele <thomas@apestaart.org>
Date: Sun, 14 Mar 2004 22:34:33 +0000
Subject: gst-indent

Original commit message from CVS:
gst-indent
---
 sys/qcam/dark.c       |  65 +++---
 sys/qcam/exposure.c   |  99 ++++-----
 sys/qcam/gstqcamsrc.c | 274 +++++++++++------------
 sys/qcam/gstqcamsrc.h |  48 ++--
 sys/qcam/qcam-Linux.c | 202 +++++++++--------
 sys/qcam/qcam-Linux.h |   2 -
 sys/qcam/qcam-lib.c   | 595 +++++++++++++++++++++++++++-----------------------
 sys/qcam/qcam-os.c    | 202 +++++++++--------
 sys/qcam/qcam-os.h    |   2 -
 sys/qcam/qcam.h       | 117 +++++-----
 sys/qcam/qcamip.h     |  18 +-
 11 files changed, 869 insertions(+), 755 deletions(-)

(limited to 'sys/qcam')

diff --git a/sys/qcam/dark.c b/sys/qcam/dark.c
index 70acf979..e15a53c9 100644
--- a/sys/qcam/dark.c
+++ b/sys/qcam/dark.c
@@ -50,8 +50,8 @@ OTHER DEALINGS IN THE SOFTWARE.
 #define FNAME "qcam.darkfile"
 
 static unsigned char master_darkmask1[MAX_HEIGHT][MAX_WIDTH];
-static unsigned char master_darkmask2[MAX_HEIGHT/2+1][MAX_WIDTH/2+1];
-static unsigned char master_darkmask4[MAX_HEIGHT/4+1][MAX_WIDTH/4+1];
+static unsigned char master_darkmask2[MAX_HEIGHT / 2 + 1][MAX_WIDTH / 2 + 1];
+static unsigned char master_darkmask4[MAX_HEIGHT / 4 + 1][MAX_WIDTH / 4 + 1];
 
 /*
 int
@@ -133,7 +133,7 @@ read_darkmask()
 */
 
 int
-fixdark(const struct qcam *q, scanbuf *scan)
+fixdark (const struct qcam *q, scanbuf * scan)
 {
   static int init = 0;
   static int smallest_dm = 255;
@@ -150,14 +150,15 @@ fixdark(const struct qcam *q, scanbuf *scan)
   int scale = q->transfer_scale;
 
   if (!init) {
-    if (!read_darkmask()) return 0;
+    if (!read_darkmask ())
+      return 0;
     for (y = 0; y < MAX_HEIGHT; y++)
       for (x = 0; x < MAX_HEIGHT; x++)
-        if (master_darkmask1[y][x] < smallest_dm) {
+	if (master_darkmask1[y][x] < smallest_dm) {
 	  smallest_dm = master_darkmask1[y][x];
 #ifdef DEBUG
-	  fprintf(stderr, "Smallest mask is %d at (%d, %d)\n",
-		smallest_dm, x, y);
+	  fprintf (stderr, "Smallest mask is %d at (%d, %d)\n",
+	      smallest_dm, x, y);
 #endif
 	}
     init = 1;
@@ -165,7 +166,8 @@ fixdark(const struct qcam *q, scanbuf *scan)
 
   if (brightness < smallest_dm) {
 #ifdef DEBUG
-    fprintf(stderr, "Brightness %d (dark current starts at %d), no fixup needed\n",
+    fprintf (stderr,
+	"Brightness %d (dark current starts at %d), no fixup needed\n",
 	brightness, smallest_dm);
 #endif
     return 1;
@@ -186,53 +188,53 @@ fixdark(const struct qcam *q, scanbuf *scan)
 	darkmask[y][x] = master_darkmask4[y][x];
       } else {
 #ifdef DEBUG
-	fprintf(stderr, "Bad transfer_scale in darkmask assignment!\n");
+	fprintf (stderr, "Bad transfer_scale in darkmask assignment!\n");
 #endif
 	return 0;
       }
 
   do {
     again = 0;
-    ccd_y = (q->top-1)/scale;
+    ccd_y = (q->top - 1) / scale;
     for (y = 0; y < height; y++, ccd_y++) {
-      ccd_x = q->left-1;
+      ccd_x = q->left - 1;
       ccd_x /= 2;
       ccd_x *= 2;
       ccd_x /= scale;
       for (x = 0; x < width; x++, ccd_x++) {
-        val = scan[y*width + x];
-        if (brightness < darkmask[ccd_y][ccd_x]) { /* good pixel */
+	val = scan[y * width + x];
+	if (brightness < darkmask[ccd_y][ccd_x]) {	/* good pixel */
 	  new_image[y][x] = val;
-	} else { /* bad pixel */
+	} else {		/* bad pixel */
 	  /* look at nearby pixels, average the good values */
 	  pixelcount = 0;
 	  pixeltotal = 0;
-	  if (x > 0) { /* left */
-	    if (brightness < darkmask[ccd_y][ccd_x-1]) {
+	  if (x > 0) {		/* left */
+	    if (brightness < darkmask[ccd_y][ccd_x - 1]) {
 	      pixelcount++;
-	      pixeltotal += scan[y*width + x - 1];
+	      pixeltotal += scan[y * width + x - 1];
 	    }
 	  }
-	  if (x < width-1) { /* right */
-	    if (brightness < darkmask[ccd_y][ccd_x+1]) {
+	  if (x < width - 1) {	/* right */
+	    if (brightness < darkmask[ccd_y][ccd_x + 1]) {
 	      pixelcount++;
-	      pixeltotal += scan[y*width + x + 1];
+	      pixeltotal += scan[y * width + x + 1];
 	    }
 	  }
-	  if (y > 0) { /* above */
-	    if (brightness < darkmask[ccd_y-1][ccd_x]) {
+	  if (y > 0) {		/* above */
+	    if (brightness < darkmask[ccd_y - 1][ccd_x]) {
 	      pixelcount++;
-	      pixeltotal += scan[(y-1)*width + x];
+	      pixeltotal += scan[(y - 1) * width + x];
 	    }
 	  }
-	  if (y < height-1) { /* below */
-	    if (brightness < darkmask[ccd_y+1][ccd_x]) {
+	  if (y < height - 1) {	/* below */
+	    if (brightness < darkmask[ccd_y + 1][ccd_x]) {
 	      pixelcount++;
-	      pixeltotal += scan[(y+1)*width + x];
+	      pixeltotal += scan[(y + 1) * width + x];
 	    }
 	  }
- 
-	  if (pixelcount == 0) { /* no valid neighbors! */
+
+	  if (pixelcount == 0) {	/* no valid neighbors! */
 	    again = 1;
 	  } else {
 	    new_image[y][x] = pixeltotal / pixelcount;
@@ -245,13 +247,12 @@ fixdark(const struct qcam *q, scanbuf *scan)
 
     for (y = 0; y < height; y++)
       for (x = 0; x < width; x++)
-	scan[y*width + x] = new_image[y][x];
+	scan[y * width + x] = new_image[y][x];
 
   } while (loopcount++ < MAX_LOOPS && again);
 #ifdef DEBUG
-  fprintf(stderr, "Darkmask fix took %d loop%s\n",
-    loopcount, (loopcount == 1)?"":"s");
+  fprintf (stderr, "Darkmask fix took %d loop%s\n",
+      loopcount, (loopcount == 1) ? "" : "s");
 #endif
   return 1;
 }
-
diff --git a/sys/qcam/exposure.c b/sys/qcam/exposure.c
index b393bdb7..b63e364f 100644
--- a/sys/qcam/exposure.c
+++ b/sys/qcam/exposure.c
@@ -49,8 +49,8 @@ SOFTWARE.
  * prototyped in qcamip.h
  */
 
-static int qcip_pixel_average(struct qcam *q, scanbuf *scan);
-static int qcip_luminance_std(struct qcam *q, scanbuf *scan, int avg);
+static int qcip_pixel_average (struct qcam *q, scanbuf * scan);
+static int qcip_luminance_std (struct qcam *q, scanbuf * scan, int avg);
 
 /* Private data used by the auto exposure routine */
 
@@ -63,7 +63,7 @@ static int ae_mode = AE_ALL_AVG;
 /* Calculate average pixel value for entire image */
 
 static int
-qcip_pixel_average(struct qcam *q, scanbuf *scan)
+qcip_pixel_average (struct qcam *q, scanbuf * scan)
 {
   int count = 0;
   int sum = 0;
@@ -83,7 +83,7 @@ qcip_pixel_average(struct qcam *q, scanbuf *scan)
 /* Calculate average pixel value for center of image */
 
 static int
-qcip_pixel_average_center(struct qcam *q, scanbuf *scan)
+qcip_pixel_average_center (struct qcam *q, scanbuf * scan)
 {
   int count = 0;
   int sum = 0;
@@ -95,12 +95,12 @@ qcip_pixel_average_center(struct qcam *q, scanbuf *scan)
   width = q->width / q->transfer_scale;
   height = q->height / q->transfer_scale;
 
-  maxcol = width  * 2 / 3;
+  maxcol = width * 2 / 3;
   maxrow = height * 2 / 3;
 
-  for (i = width/3; i < maxcol; i++) {
-    for (j = height/3; j < maxrow; j++) {
-      sum += scan[j*width+i];
+  for (i = width / 3; i < maxcol; i++) {
+    for (j = height / 3; j < maxrow; j++) {
+      sum += scan[j * width + i];
       count++;
     }
   }
@@ -108,7 +108,7 @@ qcip_pixel_average_center(struct qcam *q, scanbuf *scan)
 }
 
 int
-qcip_set_luminance_target(struct qcam *q, int val)
+qcip_set_luminance_target (struct qcam *q, int val)
 {
   const int max_pixel_val = q->bpp == 6 ? 63 : 15;
 
@@ -121,7 +121,7 @@ qcip_set_luminance_target(struct qcam *q, int val)
 }
 
 int
-qcip_set_luminance_tolerance(struct qcam *q, int val)
+qcip_set_luminance_tolerance (struct qcam *q, int val)
 {
   const int max_pixel_val = q->bpp == 6 ? 63 : 15;
 
@@ -139,21 +139,21 @@ qcip_set_luminance_tolerance(struct qcam *q, int val)
 }
 
 int
-qcip_set_luminance_std_target(struct qcam *q, int val)
+qcip_set_luminance_std_target (struct qcam *q, int val)
 {
   luminance_std_target = val;
   return QCIP_XPSR_OK;
 }
 
 int
-qcip_set_luminance_std_tolerance(struct qcam *q, int val)
+qcip_set_luminance_std_tolerance (struct qcam *q, int val)
 {
   luminance_std_tolerance = val;
   return QCIP_XPSR_OK;
 }
 
 int
-qcip_set_autoexposure_mode(int val)
+qcip_set_autoexposure_mode (int val)
 {
   ae_mode = val;
   return 0;
@@ -162,7 +162,7 @@ qcip_set_autoexposure_mode(int val)
 /* Calculate standard deviation of pixel value for entire image */
 
 static int
-qcip_luminance_std(struct qcam *q, scanbuf *scan, int avg)
+qcip_luminance_std (struct qcam *q, scanbuf * scan, int avg)
 {
   int count = 0;
   int sum = 0;
@@ -197,7 +197,7 @@ qcip_luminance_std(struct qcam *q, scanbuf *scan, int avg)
  */
 
 int
-qcip_autoexposure(struct qcam *q, scanbuf *scan)
+qcip_autoexposure (struct qcam *q, scanbuf * scan)
 {
   int luminance_dif;
   int luminance_avg;
@@ -207,45 +207,46 @@ qcip_autoexposure(struct qcam *q, scanbuf *scan)
   int ret = QCIP_XPSR_OK;
 
 #ifdef DEBUG
-  fprintf(stderr, "Brightness: %d  Contrast: %d\n",
-	  qc_getbrightness(q), qc_getcontrast(q));
+  fprintf (stderr, "Brightness: %d  Contrast: %d\n",
+      qc_getbrightness (q), qc_getcontrast (q));
 #endif
 
   switch (ae_mode) {
-  case AE_CTR_AVG:
-    luminance_avg = qcip_pixel_average_center(q, scan);
-    break;
-  case AE_STD_AVG:
-    luminance_avg = qcip_pixel_average(q, scan);
-    lum_std = qcip_luminance_std(q, scan, luminance_avg);
-
-    /* ==>> Contrast adjustment <<== */
-
-    /* set target if it has not been explicitly set */
-    if (luminance_std_target == -1) {
-      luminance_std_target = q->bpp == 6 ? 10 : 2;
-    }
+    case AE_CTR_AVG:
+      luminance_avg = qcip_pixel_average_center (q, scan);
+      break;
+    case AE_STD_AVG:
+      luminance_avg = qcip_pixel_average (q, scan);
+      lum_std = qcip_luminance_std (q, scan, luminance_avg);
+
+      /* ==>> Contrast adjustment <<== */
+
+      /* set target if it has not been explicitly set */
+      if (luminance_std_target == -1) {
+	luminance_std_target = q->bpp == 6 ? 10 : 2;
+      }
 
-    /* Adjust contrast to reach target luminance standard deviation */
-    lum_std_min = luminance_std_target - luminance_std_tolerance;
-    lum_std_max = luminance_std_target + luminance_std_tolerance;
+      /* Adjust contrast to reach target luminance standard deviation */
+      lum_std_min = luminance_std_target - luminance_std_tolerance;
+      lum_std_max = luminance_std_target + luminance_std_tolerance;
 
-    if (lum_std < lum_std_min || lum_std > lum_std_max) {
-      ret = QCIP_XPSR_RSCN;
-      if (qc_setcontrast(q, luminance_std_target - lum_std + qc_getcontrast(q))) {
-	return QCIP_XPSR_ERR;
+      if (lum_std < lum_std_min || lum_std > lum_std_max) {
+	ret = QCIP_XPSR_RSCN;
+	if (qc_setcontrast (q,
+		luminance_std_target - lum_std + qc_getcontrast (q))) {
+	  return QCIP_XPSR_ERR;
+	}
       }
-    }
 #ifdef DEBUG
-    fprintf(stderr, "Luminance std/target/tolerance: %d/%d/%d\n",
-	    lum_std, luminance_std_target, luminance_std_tolerance );
+      fprintf (stderr, "Luminance std/target/tolerance: %d/%d/%d\n",
+	  lum_std, luminance_std_target, luminance_std_tolerance);
 #endif
-    
-    break;
-  case AE_ALL_AVG:
-  default:
-    luminance_avg = qcip_pixel_average(q, scan);
-    break;
+
+      break;
+    case AE_ALL_AVG:
+    default:
+      luminance_avg = qcip_pixel_average (q, scan);
+      break;
   }
 
   /* ==>> Brightness adjustment <<== */
@@ -259,8 +260,8 @@ qcip_autoexposure(struct qcam *q, scanbuf *scan)
   lum_max = luminance_target + luminance_tolerance;
 
 #ifdef DEBUG
-  fprintf(stderr, "Luminance avg/target/tolerance: %d/%d/%d\n",
-	  luminance_avg, luminance_target, luminance_tolerance );
+  fprintf (stderr, "Luminance avg/target/tolerance: %d/%d/%d\n",
+      luminance_avg, luminance_target, luminance_tolerance);
 #endif
 
   /* check for luminance within target range */
@@ -277,7 +278,7 @@ qcip_autoexposure(struct qcam *q, scanbuf *scan)
     /* Adjusted brightness is out of range ..
      * throw in the towel ... auto-exposure has failed!
      */
-    if (qc_setbrightness(q, brightness_adj + qc_getbrightness(q))) {
+    if (qc_setbrightness (q, brightness_adj + qc_getbrightness (q))) {
       return QCIP_XPSR_ERR;
     }
   }
diff --git a/sys/qcam/gstqcamsrc.c b/sys/qcam/gstqcamsrc.c
index 04de351f..0c68ca13 100644
--- a/sys/qcam/gstqcamsrc.c
+++ b/sys/qcam/gstqcamsrc.c
@@ -34,12 +34,11 @@
 #include "qcamip.h"
 
 /* elementfactory information */
-static GstElementDetails gst_qcamsrc_details = GST_ELEMENT_DETAILS (
-  "QCam Source",
-  "Source/Video",
-  "Read from a QuickCam device",
-  "Wim Taymans <wim.taymans@chello.be>"
-);
+static GstElementDetails gst_qcamsrc_details =
+GST_ELEMENT_DETAILS ("QCam Source",
+    "Source/Video",
+    "Read from a QuickCam device",
+    "Wim Taymans <wim.taymans@chello.be>");
 
 #define AE_NONE			3
 
@@ -56,12 +55,11 @@ static GstElementDetails gst_qcamsrc_details = GST_ELEMENT_DETAILS (
 #define DEF_AUTOEXP		AE_NONE
 
 static GstStaticPadTemplate gst_qcamsrc_src_factory =
-GST_STATIC_PAD_TEMPLATE (
-  "src",
-  GST_PAD_SRC,
-  GST_PAD_ALWAYS,
-  GST_STATIC_CAPS (GST_VIDEO_CAPS_YUV("I420"))
-);
+GST_STATIC_PAD_TEMPLATE ("src",
+    GST_PAD_SRC,
+    GST_PAD_ALWAYS,
+    GST_STATIC_CAPS (GST_VIDEO_CAPS_YUV ("I420"))
+    );
 
 #define GST_TYPE_AUTOEXP_MODE (gst_autoexp_mode_get_type())
 static GType
@@ -69,25 +67,28 @@ gst_autoexp_mode_get_type (void)
 {
   static GType autoexp_mode_type = 0;
   static GEnumValue autoexp_modes[] = {
-    { AE_ALL_AVG, "0", "Average Picture" },
-    { AE_CTR_AVG, "1", "Average Center" },
-    { AE_STD_AVG, "2", "Standard Deviation" },
-    { AE_NONE,    "3", "None" },
-    { 0, NULL, NULL },
+    {AE_ALL_AVG, "0", "Average Picture"},
+    {AE_CTR_AVG, "1", "Average Center"},
+    {AE_STD_AVG, "2", "Standard Deviation"},
+    {AE_NONE, "3", "None"},
+    {0, NULL, NULL},
   };
   if (!autoexp_mode_type) {
-    autoexp_mode_type = g_enum_register_static ("GstAutoExposureMode", autoexp_modes);
+    autoexp_mode_type =
+	g_enum_register_static ("GstAutoExposureMode", autoexp_modes);
   }
   return autoexp_mode_type;
 }
 
 /* QCamSrc signals and args */
-enum {
+enum
+{
   /* FILL ME */
   LAST_SIGNAL
 };
 
-enum {
+enum
+{
   ARG_0,
   ARG_WIDTH,
   ARG_HEIGHT,
@@ -102,22 +103,23 @@ enum {
   ARG_AUTOEXP,
 };
 
-static void			gst_qcamsrc_base_init		(gpointer g_class);
-static void			gst_qcamsrc_class_init		(GstQCamSrcClass *klass);
-static void			gst_qcamsrc_init		(GstQCamSrc *qcamsrc);
+static void gst_qcamsrc_base_init (gpointer g_class);
+static void gst_qcamsrc_class_init (GstQCamSrcClass * klass);
+static void gst_qcamsrc_init (GstQCamSrc * qcamsrc);
 
-static void			gst_qcamsrc_set_property	(GObject *object, guint prop_id, 
-								 const GValue *value, GParamSpec *pspec);
-static void			gst_qcamsrc_get_property	(GObject *object, guint prop_id, 
-								 GValue *value, GParamSpec *pspec);
+static void gst_qcamsrc_set_property (GObject * object, guint prop_id,
+    const GValue * value, GParamSpec * pspec);
+static void gst_qcamsrc_get_property (GObject * object, guint prop_id,
+    GValue * value, GParamSpec * pspec);
 
-static GstElementStateReturn	gst_qcamsrc_change_state	(GstElement *element);
-static void			gst_qcamsrc_close		(GstQCamSrc *src);
-static gboolean			gst_qcamsrc_open		(GstQCamSrc *src);
+static GstElementStateReturn gst_qcamsrc_change_state (GstElement * element);
+static void gst_qcamsrc_close (GstQCamSrc * src);
+static gboolean gst_qcamsrc_open (GstQCamSrc * src);
 
-static GstData*		gst_qcamsrc_get			(GstPad *pad);
+static GstData *gst_qcamsrc_get (GstPad * pad);
 
 static GstElementClass *parent_class = NULL;
+
 /*//static guint gst_qcamsrc_signals[LAST_SIGNAL] = { 0 }; */
 
 GType
@@ -127,18 +129,20 @@ gst_qcamsrc_get_type (void)
 
   if (!qcamsrc_type) {
     static const GTypeInfo qcamsrc_info = {
-      sizeof(GstQCamSrcClass),      
+      sizeof (GstQCamSrcClass),
       gst_qcamsrc_base_init,
       NULL,
-      (GClassInitFunc)gst_qcamsrc_class_init,
+      (GClassInitFunc) gst_qcamsrc_class_init,
       NULL,
       NULL,
-      sizeof(GstQCamSrc),
+      sizeof (GstQCamSrc),
       0,
-      (GInstanceInitFunc)gst_qcamsrc_init,
+      (GInstanceInitFunc) gst_qcamsrc_init,
       NULL
     };
-    qcamsrc_type = g_type_register_static(GST_TYPE_ELEMENT, "GstQCamSrc", &qcamsrc_info, 0);
+    qcamsrc_type =
+	g_type_register_static (GST_TYPE_ELEMENT, "GstQCamSrc", &qcamsrc_info,
+	0);
   }
   return qcamsrc_type;
 }
@@ -146,54 +150,55 @@ static void
 gst_qcamsrc_base_init (gpointer g_class)
 {
   GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
-  
-  gst_element_class_add_pad_template (element_class, gst_static_pad_template_get (&gst_qcamsrc_src_factory));
+
+  gst_element_class_add_pad_template (element_class,
+      gst_static_pad_template_get (&gst_qcamsrc_src_factory));
   gst_element_class_set_details (element_class, &gst_qcamsrc_details);
 }
 static void
-gst_qcamsrc_class_init (GstQCamSrcClass *klass)
+gst_qcamsrc_class_init (GstQCamSrcClass * klass)
 {
   GObjectClass *gobject_class;
   GstElementClass *gstelement_class;
 
-  gobject_class = (GObjectClass*)klass;
-  gstelement_class = (GstElementClass*)klass;
+  gobject_class = (GObjectClass *) klass;
+  gstelement_class = (GstElementClass *) klass;
 
-  parent_class = g_type_class_ref(GST_TYPE_ELEMENT);
+  parent_class = g_type_class_ref (GST_TYPE_ELEMENT);
 
   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_WIDTH,
-    g_param_spec_int ("width", "width", "width",
-                      0, 320, DEF_WIDTH, G_PARAM_READWRITE)); 
-  g_object_class_install_property (G_OBJECT_CLASS(klass), ARG_HEIGHT,
-    g_param_spec_int ("height", "height", "height",
-                      0, 240, DEF_HEIGHT, G_PARAM_READWRITE)); 
-  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_BRIGHTNESS,
-    g_param_spec_int ("brightness", "brightness", "brightness",
-                      0, 255, DEF_BRIGHTNESS, G_PARAM_READWRITE));
-  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_WHITEBAL,
-    g_param_spec_int ("whitebal", "whitebal", "whitebal",
-                      0, 255, DEF_WHITEBAL, G_PARAM_READWRITE));
-  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_CONTRAST,
-    g_param_spec_int ("contrast", "contrast", "contrast",
-                      0, 255, DEF_CONTRAST, G_PARAM_READWRITE));
-  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_TOP,
-    g_param_spec_int ("top", "top", "top",
-                      0, 240, DEF_TOP, G_PARAM_READWRITE));
-  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_LEFT,
-    g_param_spec_int ("left", "left", "left",
-                      0, 320, DEF_LEFT, G_PARAM_READWRITE));
-  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_TRANSFER_SCALE,
-    g_param_spec_int ("transfer_scale", "transfer_scale", "transfer_scale",
-                      1, 4, DEF_TRANSFER_SCALE, G_PARAM_READWRITE));
-  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_DEPTH,
-    g_param_spec_int ("depth", "depth", "depth",
-                      4, 6, DEF_DEPTH, G_PARAM_READWRITE));
-  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_PORT,
-    g_param_spec_int ("port","port","port",
-                      0, G_MAXINT, DEF_PORT, G_PARAM_READWRITE));
-  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_AUTOEXP,
-    g_param_spec_enum ("autoexposure", "autoexposure", "autoexposure",
-                       GST_TYPE_AUTOEXP_MODE, DEF_AUTOEXP, G_PARAM_READWRITE));
+      g_param_spec_int ("width", "width", "width",
+	  0, 320, DEF_WIDTH, G_PARAM_READWRITE));
+  g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_HEIGHT,
+      g_param_spec_int ("height", "height", "height",
+	  0, 240, DEF_HEIGHT, G_PARAM_READWRITE));
+  g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_BRIGHTNESS,
+      g_param_spec_int ("brightness", "brightness", "brightness",
+	  0, 255, DEF_BRIGHTNESS, G_PARAM_READWRITE));
+  g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_WHITEBAL,
+      g_param_spec_int ("whitebal", "whitebal", "whitebal",
+	  0, 255, DEF_WHITEBAL, G_PARAM_READWRITE));
+  g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_CONTRAST,
+      g_param_spec_int ("contrast", "contrast", "contrast",
+	  0, 255, DEF_CONTRAST, G_PARAM_READWRITE));
+  g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_TOP,
+      g_param_spec_int ("top", "top", "top",
+	  0, 240, DEF_TOP, G_PARAM_READWRITE));
+  g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_LEFT,
+      g_param_spec_int ("left", "left", "left",
+	  0, 320, DEF_LEFT, G_PARAM_READWRITE));
+  g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_TRANSFER_SCALE,
+      g_param_spec_int ("transfer_scale", "transfer_scale", "transfer_scale",
+	  1, 4, DEF_TRANSFER_SCALE, G_PARAM_READWRITE));
+  g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_DEPTH,
+      g_param_spec_int ("depth", "depth", "depth",
+	  4, 6, DEF_DEPTH, G_PARAM_READWRITE));
+  g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_PORT,
+      g_param_spec_int ("port", "port", "port",
+	  0, G_MAXINT, DEF_PORT, G_PARAM_READWRITE));
+  g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_AUTOEXP,
+      g_param_spec_enum ("autoexposure", "autoexposure", "autoexposure",
+	  GST_TYPE_AUTOEXP_MODE, DEF_AUTOEXP, G_PARAM_READWRITE));
 
   gobject_class->set_property = gst_qcamsrc_set_property;
   gobject_class->get_property = gst_qcamsrc_get_property;
@@ -202,15 +207,16 @@ gst_qcamsrc_class_init (GstQCamSrcClass *klass)
 }
 
 static void
-gst_qcamsrc_init (GstQCamSrc *qcamsrc)
+gst_qcamsrc_init (GstQCamSrc * qcamsrc)
 {
-  qcamsrc->srcpad = gst_pad_new_from_template (
-		  gst_static_pad_template_get (&gst_qcamsrc_src_factory), "src");
-  gst_element_add_pad(GST_ELEMENT(qcamsrc),qcamsrc->srcpad);
-  gst_pad_set_get_function (qcamsrc->srcpad,gst_qcamsrc_get);
+  qcamsrc->srcpad =
+      gst_pad_new_from_template (gst_static_pad_template_get
+      (&gst_qcamsrc_src_factory), "src");
+  gst_element_add_pad (GST_ELEMENT (qcamsrc), qcamsrc->srcpad);
+  gst_pad_set_get_function (qcamsrc->srcpad, gst_qcamsrc_get);
 
   /* if the destination cannot say what it wants, we give this */
-  qcamsrc->qcam = qc_init();
+  qcamsrc->qcam = qc_init ();
   qcamsrc->qcam->port = DEF_PORT;
   qc_setwidth (qcamsrc->qcam, DEF_WIDTH);
   qc_setheight (qcamsrc->qcam, DEF_HEIGHT);
@@ -222,12 +228,12 @@ gst_qcamsrc_init (GstQCamSrc *qcamsrc)
   qc_settransfer_scale (qcamsrc->qcam, DEF_TRANSFER_SCALE);
   qc_setbitdepth (qcamsrc->qcam, DEF_DEPTH);
   qcamsrc->autoexposure = DEF_AUTOEXP;
-  if (qcamsrc->autoexposure != AE_NONE) 
+  if (qcamsrc->autoexposure != AE_NONE)
     qcip_set_autoexposure_mode (qcamsrc->autoexposure);
 }
 
-static GstData*
-gst_qcamsrc_get (GstPad *pad)
+static GstData *
+gst_qcamsrc_get (GstPad * pad)
 {
   GstQCamSrc *qcamsrc;
   GstBuffer *buf;
@@ -243,45 +249,46 @@ gst_qcamsrc_get (GstPad *pad)
 
   frame = qcamsrc->qcam->width * qcamsrc->qcam->height / (scale * scale);
 
-  buf = gst_buffer_new();
-  outdata = GST_BUFFER_DATA(buf) = g_malloc0((frame * 3) / 2);
-  GST_BUFFER_SIZE(buf) = (frame * 3) / 2;
+  buf = gst_buffer_new ();
+  outdata = GST_BUFFER_DATA (buf) = g_malloc0 ((frame * 3) / 2);
+  GST_BUFFER_SIZE (buf) = (frame * 3) / 2;
 
   qc_set (qcamsrc->qcam);
   if (!GST_PAD_CAPS (pad)) {
-    gst_pad_try_set_caps (pad, gst_caps_new_simple("video/x-raw-yuv",
-	  "format",    GST_TYPE_FOURCC, "I420",
-	  "width",     G_TYPE_INT, qcamsrc->qcam->width / scale,
-	  "height",    G_TYPE_INT, qcamsrc->qcam->height / scale,
-	  "framerate", G_TYPE_DOUBLE, 10., NULL));
+    gst_pad_try_set_caps (pad, gst_caps_new_simple ("video/x-raw-yuv",
+	    "format", GST_TYPE_FOURCC, "I420",
+	    "width", G_TYPE_INT, qcamsrc->qcam->width / scale,
+	    "height", G_TYPE_INT, qcamsrc->qcam->height / scale,
+	    "framerate", G_TYPE_DOUBLE, 10., NULL));
   }
   scan = qc_scan (qcamsrc->qcam);
 
   /* FIXME, this doesn't seem to work... */
   /*fixdark(qcamsrc->qcam, scan); */
-  
-  if (qcamsrc->autoexposure != AE_NONE) 
-    qcip_autoexposure(qcamsrc->qcam, scan);
 
-  convert = (qcamsrc->qcam->bpp==4?4:2);
+  if (qcamsrc->autoexposure != AE_NONE)
+    qcip_autoexposure (qcamsrc->qcam, scan);
+
+  convert = (qcamsrc->qcam->bpp == 4 ? 4 : 2);
 
-  for (i=frame; i; i--) {
-    outdata[i] = scan[i]<<convert; 
+  for (i = frame; i; i--) {
+    outdata[i] = scan[i] << convert;
   }
-  memset (outdata+frame, 128, frame>>1);
+  memset (outdata + frame, 128, frame >> 1);
   g_free (scan);
 
   return GST_DATA (buf);
 }
 
 static void
-gst_qcamsrc_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
+gst_qcamsrc_set_property (GObject * object, guint prop_id, const GValue * value,
+    GParamSpec * pspec)
 {
   GstQCamSrc *src;
 
   /* it's not null if we got it, but it might not be ours */
-  g_return_if_fail(GST_IS_QCAMSRC(object));
-  src = GST_QCAMSRC(object);
+  g_return_if_fail (GST_IS_QCAMSRC (object));
+  src = GST_QCAMSRC (object);
 
   switch (prop_id) {
     case ARG_WIDTH:
@@ -316,8 +323,8 @@ gst_qcamsrc_set_property (GObject *object, guint prop_id, const GValue *value, G
       break;
     case ARG_AUTOEXP:
       src->autoexposure = g_value_get_enum (value);
-      if (src->autoexposure != AE_NONE) 
-        qcip_set_autoexposure_mode (src->autoexposure);
+      if (src->autoexposure != AE_NONE)
+	qcip_set_autoexposure_mode (src->autoexposure);
       break;
     default:
       break;
@@ -325,13 +332,14 @@ gst_qcamsrc_set_property (GObject *object, guint prop_id, const GValue *value, G
 }
 
 static void
-gst_qcamsrc_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
+gst_qcamsrc_get_property (GObject * object, guint prop_id, GValue * value,
+    GParamSpec * pspec)
 {
   GstQCamSrc *src;
 
   /* it's not null if we got it, but it might not be ours */
-  g_return_if_fail(GST_IS_QCAMSRC(object));
-  src = GST_QCAMSRC(object);
+  g_return_if_fail (GST_IS_QCAMSRC (object));
+  src = GST_QCAMSRC (object);
 
   switch (prop_id) {
     case ARG_WIDTH:
@@ -374,69 +382,63 @@ gst_qcamsrc_get_property (GObject *object, guint prop_id, GValue *value, GParamS
 }
 
 static GstElementStateReturn
-gst_qcamsrc_change_state (GstElement *element)
+gst_qcamsrc_change_state (GstElement * element)
 {
-  g_return_val_if_fail(GST_IS_QCAMSRC(element), FALSE);
+  g_return_val_if_fail (GST_IS_QCAMSRC (element), FALSE);
 
   /* if going down into NULL state, close the file if it's open */
-  if (GST_STATE_PENDING(element) == GST_STATE_NULL) {
-    if (GST_FLAG_IS_SET(element,GST_QCAMSRC_OPEN))
-      gst_qcamsrc_close(GST_QCAMSRC(element));
-  /* otherwise (READY or higher) we need to open the sound card */
+  if (GST_STATE_PENDING (element) == GST_STATE_NULL) {
+    if (GST_FLAG_IS_SET (element, GST_QCAMSRC_OPEN))
+      gst_qcamsrc_close (GST_QCAMSRC (element));
+    /* otherwise (READY or higher) we need to open the sound card */
   } else {
-    if (!GST_FLAG_IS_SET(element,GST_QCAMSRC_OPEN)) {
+    if (!GST_FLAG_IS_SET (element, GST_QCAMSRC_OPEN)) {
       gst_info ("qcamsrc: opening\n");
-      if (!gst_qcamsrc_open(GST_QCAMSRC(element))) {
+      if (!gst_qcamsrc_open (GST_QCAMSRC (element))) {
 	gst_info ("qcamsrc: open failed\n");
-        return GST_STATE_FAILURE;
+	return GST_STATE_FAILURE;
       }
     }
   }
 
-  if (GST_ELEMENT_CLASS(parent_class)->change_state)
-    return GST_ELEMENT_CLASS(parent_class)->change_state(element);
+  if (GST_ELEMENT_CLASS (parent_class)->change_state)
+    return GST_ELEMENT_CLASS (parent_class)->change_state (element);
 
   return GST_STATE_SUCCESS;
 }
 
 static gboolean
-gst_qcamsrc_open (GstQCamSrc *qcamsrc)
+gst_qcamsrc_open (GstQCamSrc * qcamsrc)
 {
   if (qc_open (qcamsrc->qcam)) {
-    g_warning("qcamsrc: Cannot open QuickCam.\n");
+    g_warning ("qcamsrc: Cannot open QuickCam.\n");
     return FALSE;
   }
 
-  GST_FLAG_SET(qcamsrc, GST_QCAMSRC_OPEN);
+  GST_FLAG_SET (qcamsrc, GST_QCAMSRC_OPEN);
 
   return TRUE;
 }
 
 static void
-gst_qcamsrc_close (GstQCamSrc *src)
+gst_qcamsrc_close (GstQCamSrc * src)
 {
   qc_close (src->qcam);
-  GST_FLAG_UNSET(src, GST_QCAMSRC_OPEN);
+  GST_FLAG_UNSET (src, GST_QCAMSRC_OPEN);
 }
 
 static gboolean
-plugin_init (GstPlugin *plugin)
+plugin_init (GstPlugin * plugin)
 {
-  if (!gst_element_register (plugin, "qcamsrc", GST_RANK_NONE, GST_TYPE_QCAMSRC))
+  if (!gst_element_register (plugin, "qcamsrc", GST_RANK_NONE,
+	  GST_TYPE_QCAMSRC))
     return FALSE;
 
   return TRUE;
 }
 
-GST_PLUGIN_DEFINE (
-  GST_VERSION_MAJOR,
-  GST_VERSION_MINOR,
-  "qcamsrc",
-  "Read from a QuickCam device",
-  plugin_init,
-  VERSION,
-  GST_LICENSE,
-  GST_PACKAGE,
-  GST_ORIGIN
-)
-
+GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
+    GST_VERSION_MINOR,
+    "qcamsrc",
+    "Read from a QuickCam device",
+    plugin_init, VERSION, GST_LICENSE, GST_PACKAGE, GST_ORIGIN)
diff --git a/sys/qcam/gstqcamsrc.h b/sys/qcam/gstqcamsrc.h
index 0bd201c8..c6e763d4 100644
--- a/sys/qcam/gstqcamsrc.h
+++ b/sys/qcam/gstqcamsrc.h
@@ -25,8 +25,9 @@
 #include <gst/gst.h>
 
 #ifdef __cplusplus
-extern "C" {
-#endif /* __cplusplus */
+extern "C"
+{
+#endif				/* __cplusplus */
 
 /** QuickCam include files */
 #include "qcam.h"
@@ -44,35 +45,38 @@ extern "C" {
   (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_QCAMSRC))
 
 /* NOTE: per-element flags start with 16 for now */
-typedef enum {
-  GST_QCAMSRC_OPEN            = GST_ELEMENT_FLAG_LAST,
+  typedef enum
+  {
+    GST_QCAMSRC_OPEN = GST_ELEMENT_FLAG_LAST,
 
-  GST_QCAMSRC_FLAG_LAST       = GST_ELEMENT_FLAG_LAST+2,
-} GstQCamSrcFlags;
+    GST_QCAMSRC_FLAG_LAST = GST_ELEMENT_FLAG_LAST + 2,
+  } GstQCamSrcFlags;
 
-typedef struct _GstQCamSrc GstQCamSrc;
-typedef struct _GstQCamSrcClass GstQCamSrcClass;
+  typedef struct _GstQCamSrc GstQCamSrc;
+  typedef struct _GstQCamSrcClass GstQCamSrcClass;
 
-struct _GstQCamSrc {
-  GstElement element;
+  struct _GstQCamSrc
+  {
+    GstElement element;
 
-  /* pads */
-  GstPad *srcpad;
+    /* pads */
+    GstPad *srcpad;
 
-  struct qcam *qcam;
-  gboolean autoexposure;
-  gint port;
-};
+    struct qcam *qcam;
+    gboolean autoexposure;
+    gint port;
+  };
 
-struct _GstQCamSrcClass {
-  GstElementClass parent_class;
-};
+  struct _GstQCamSrcClass
+  {
+    GstElementClass parent_class;
+  };
 
-GType gst_qcamsrc_get_type(void);
+  GType gst_qcamsrc_get_type (void);
 
 #ifdef __cplusplus
 }
-#endif /* __cplusplus */
+#endif				/* __cplusplus */
 
 
-#endif /* __GST_QCAMSRC_H__ */
+#endif				/* __GST_QCAMSRC_H__ */
diff --git a/sys/qcam/qcam-Linux.c b/sys/qcam/qcam-Linux.c
index e73933d9..2c959e72 100644
--- a/sys/qcam/qcam-Linux.c
+++ b/sys/qcam/qcam-Linux.c
@@ -48,22 +48,50 @@ OTHER DEALINGS IN THE SOFTWARE.
 #include "qcam.h"
 #include "qcam-Linux.h"
 
-int __inline__ read_lpstatus(const struct qcam *q) { return inb(q->port+1); }
-int read_lpcontrol(const struct qcam *q) { return inb(q->port+2); }
-int read_lpdata(const struct qcam *q) { return inb(q->port); }
-void write_lpdata(const struct qcam *q, int d) { outb(d,q->port); }
-void write_lpcontrol(const struct qcam *q, int d) { outb(d,q->port+2); }
+int __inline__
+read_lpstatus (const struct qcam *q)
+{
+  return inb (q->port + 1);
+}
+
+int
+read_lpcontrol (const struct qcam *q)
+{
+  return inb (q->port + 2);
+}
+
+int
+read_lpdata (const struct qcam *q)
+{
+  return inb (q->port);
+}
 
-int enable_ports(const struct qcam *q) 
+void
+write_lpdata (const struct qcam *q, int d)
 {
-  if(q->port<0x278) return 1; /* Better safe than sorry */
-  if(q->port>0x3bc) return 1; 
-  return (ioperm(q->port, 3, 1));
+  outb (d, q->port);
 }
 
-int disable_ports(const struct qcam *q)
+void
+write_lpcontrol (const struct qcam *q, int d)
 {
-  return (ioperm(q->port, 3, 0));
+  outb (d, q->port + 2);
+}
+
+int
+enable_ports (const struct qcam *q)
+{
+  if (q->port < 0x278)
+    return 1;			/* Better safe than sorry */
+  if (q->port > 0x3bc)
+    return 1;
+  return (ioperm (q->port, 3, 1));
+}
+
+int
+disable_ports (const struct qcam *q)
+{
+  return (ioperm (q->port, 3, 0));
 }
 
 /* Lock port.  This is currently sub-optimal, and is begging to be
@@ -81,121 +109,118 @@ int disable_ports(const struct qcam *q)
  * multiple processes (eg. qcam) taking "snapshots" can peacefully coexist.
  * - Dave Plonka (plonka@carroll1.cc.edu)
  */
-int qc_lock_wait(struct qcam *q, int wait)
+int
+qc_lock_wait (struct qcam *q, int wait)
 {
 #if 1
   static struct flock sfl;
 
-  if (-1 == q->fd) /* we've yet to open the lock file */
-  {
-     static char lockfile[128];
-
-     sprintf(lockfile,"/var/run/LOCK.qcam.0x%x",q->port);
-     if (-1 == (q->fd = open(lockfile, O_WRONLY | O_CREAT, 0666)))
-     {
-        perror("open");
-        return 1;
-     }
+  if (-1 == q->fd) {		/* we've yet to open the lock file */
+    static char lockfile[128];
 
+    sprintf (lockfile, "/var/run/LOCK.qcam.0x%x", q->port);
+    if (-1 == (q->fd = open (lockfile, O_WRONLY | O_CREAT, 0666))) {
+      perror ("open");
+      return 1;
+    }
 #ifdef TESTING
-     fprintf(stderr, "%s - %d: %s open(2)ed\n", __FILE__, __LINE__, lockfile);
+    fprintf (stderr, "%s - %d: %s open(2)ed\n", __FILE__, __LINE__, lockfile);
 #endif
 
-     /* initialize the l_type memver to lock the file exclusively */
-     sfl.l_type = F_WRLCK;
+    /* initialize the l_type memver to lock the file exclusively */
+    sfl.l_type = F_WRLCK;
   }
-
 #ifdef TESTING
-  if (0 != fcntl(q->fd, F_SETLK, &sfl)) /* non-blocking set lock */
+  if (0 != fcntl (q->fd, F_SETLK, &sfl))	/* non-blocking set lock */
 #else
-  if (0 != fcntl(q->fd, wait? F_SETLKW : F_SETLK, &sfl))
+  if (0 != fcntl (q->fd, wait ? F_SETLKW : F_SETLK, &sfl))
 #endif
   {
 #ifdef TESTING
-     perror("fcntl");
-     if (EAGAIN != errno || !wait) return 1;
-    
-     fprintf(stderr, "%s - %d: waiting for exclusive lock on fd %d...\n", __FILE__, __LINE__, q->fd);
+    perror ("fcntl");
+    if (EAGAIN != errno || !wait)
+      return 1;
+
+    fprintf (stderr, "%s - %d: waiting for exclusive lock on fd %d...\n",
+	__FILE__, __LINE__, q->fd);
 
-     if (0 != fcntl(q->fd, F_SETLKW, &sfl)) /* "blocking" set lock */
+    if (0 != fcntl (q->fd, F_SETLKW, &sfl))	/* "blocking" set lock */
 #endif
-     {
-        perror("fcntl");
-        return 1;
-     }
+    {
+      perror ("fcntl");
+      return 1;
+    }
   }
-
 #ifdef TESTING
-  fprintf(stderr, "%s - %d: fd %d locked exclusively\n", __FILE__, __LINE__, q->fd);
+  fprintf (stderr, "%s - %d: fd %d locked exclusively\n", __FILE__, __LINE__,
+      q->fd);
 #endif
 
 #else
   char lockfile[128], tmp[128];
   struct stat statbuf;
 
-  sprintf(lockfile,"/var/run/LOCK.qcam.0x%x",q->port);
-  sprintf(tmp,"%s-%d",lockfile,getpid());
+  sprintf (lockfile, "/var/run/LOCK.qcam.0x%x", q->port);
+  sprintf (tmp, "%s-%d", lockfile, getpid ());
 
-  if ((creat(tmp,0)==-1) || 
-      (link(tmp,lockfile)==-1) ||
-      (stat(tmp,&statbuf)==-1) || 
-      (statbuf.st_nlink==1))
-  {
+  if ((creat (tmp, 0) == -1) ||
+      (link (tmp, lockfile) == -1) ||
+      (stat (tmp, &statbuf) == -1) || (statbuf.st_nlink == 1)) {
 #ifdef DEBUGQC
-    perror("QuickCam Locked");
-    if(unlink(tmp)==-1)
-      perror("Error unlinking temp file.");
+    perror ("QuickCam Locked");
+    if (unlink (tmp) == -1)
+      perror ("Error unlinking temp file.");
 #else
-    unlink(tmp);
+    unlink (tmp);
 #endif
     return 1;
   }
-  
-  unlink(tmp);
-  if (chown(lockfile,getuid(),getgid())==-1)
-    perror("Chown problems");
+
+  unlink (tmp);
+  if (chown (lockfile, getuid (), getgid ()) == -1)
+    perror ("Chown problems");
 #endif
 
   return 0;
 }
 
-int qc_lock(struct qcam *q)
+int
+qc_lock (struct qcam *q)
 {
 #if 1
-   return qc_lock_wait(q, 1 /*wait*/);
+  return qc_lock_wait (q, 1 /*wait */ );
 #else
-   return qc_lock_wait(q, 0 /*don't wait*/);
+  return qc_lock_wait (q, 0 /*don't wait */ );
 #endif
 }
 
 /* Unlock port */
 
-int qc_unlock(struct qcam *q)
+int
+qc_unlock (struct qcam *q)
 {
   static struct flock sfl;
+
 #if 1
-  if (-1 == q->fd)
-  { /* port was not locked */
-     return 1;
+  if (-1 == q->fd) {		/* port was not locked */
+    return 1;
   }
 
   /* clear the exclusive lock */
   sfl.l_type = F_UNLCK;
-  if (0 != fcntl(q->fd, F_SETLK, &sfl))
-  {
-     perror("fcntl");
-     return 1;
+  if (0 != fcntl (q->fd, F_SETLK, &sfl)) {
+    perror ("fcntl");
+    return 1;
   }
-
 #ifdef TESTING
-  fprintf(stderr, "%s - %d: fd %d unlocked\n", __FILE__, __LINE__, q->fd);
+  fprintf (stderr, "%s - %d: fd %d unlocked\n", __FILE__, __LINE__, q->fd);
 #endif
 
 #else
   char lockfile[128];
 
-  sprintf(lockfile,"/var/run/LOCK.qcam.0x%x",q->port);
-  unlink(lockfile); /* What would I do with an error? */
+  sprintf (lockfile, "/var/run/LOCK.qcam.0x%x", q->port);
+  unlink (lockfile);		/* What would I do with an error? */
 #endif
 
   return 0;
@@ -205,28 +230,28 @@ int qc_unlock(struct qcam *q)
 /* Probe for camera.  Returns 0 if found, 1 if not found, sets
    q->port.*/
 
-int qc_probe(struct qcam *q)
+int
+qc_probe (struct qcam *q)
 {
-  int ioports[]={0x378, 0x278, 0x3bc,0};
-  int i=0;
+  int ioports[] = { 0x378, 0x278, 0x3bc, 0 };
+  int i = 0;
 
   /* Attempt to get permission to access IO ports.  Must be root */
 
-  while(ioports[i]!=0) {
-    q->port=ioports[i++];
+  while (ioports[i] != 0) {
+    q->port = ioports[i++];
 
-    if (qc_open(q)) {
-      perror("Can't get I/O permission");
-      exit(1);
+    if (qc_open (q)) {
+      perror ("Can't get I/O permission");
+      exit (1);
     }
 
-    if(qc_detect(q)) {
-      fprintf(stderr,"QuickCam detected at 0x%x\n",q->port);
-      qc_close(q);
-      return(0);
-    }
-    else
-    qc_close(q);
+    if (qc_detect (q)) {
+      fprintf (stderr, "QuickCam detected at 0x%x\n", q->port);
+      qc_close (q);
+      return (0);
+    } else
+      qc_close (q);
   }
 
   return 1;
@@ -240,10 +265,11 @@ usleep(0)'s, and that's too slow -- qc_start was taking over a second
 to run.  This seems to help, but if anyone has a good
 speed-independent pause routine, please tell me. -- Scott */
 
-void qc_wait(int val)
+void
+qc_wait (int val)
 {
   int i;
-  
-  while(val--)
-    for(i=0;i<50000;i++);
+
+  while (val--)
+    for (i = 0; i < 50000; i++);
 }
diff --git a/sys/qcam/qcam-Linux.h b/sys/qcam/qcam-Linux.h
index 46dcbe51..06c1cb20 100644
--- a/sys/qcam/qcam-Linux.h
+++ b/sys/qcam/qcam-Linux.h
@@ -28,5 +28,3 @@ ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 OTHER DEALINGS IN THE SOFTWARE.
 
 ******************************************************************/
-
-
diff --git a/sys/qcam/qcam-lib.c b/sys/qcam/qcam-lib.c
index cacd5d08..e7208cdc 100644
--- a/sys/qcam/qcam-lib.c
+++ b/sys/qcam/qcam-lib.c
@@ -53,11 +53,11 @@ OTHER DEALINGS IN THE SOFTWARE.
 /* 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[]);
+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
@@ -65,15 +65,17 @@ static int qc_readbytes(const struct qcam *q, char buffer[]);
 
 /* Gets/sets the brightness. */
 
-int qc_getbrightness(const struct qcam *q)
+int
+qc_getbrightness (const struct qcam *q)
 {
   return q->brightness;
 }
 
-int qc_setbrightness(struct qcam *q, int val)
+int
+qc_setbrightness (struct qcam *q, int val)
 {
   if (val >= 0 && val <= 255) {
-    q->brightness=val;
+    q->brightness = val;
     return 0;
   }
   return 1;
@@ -82,15 +84,17 @@ int qc_setbrightness(struct qcam *q, int val)
 
 /* Gets/sets the contrast */
 
-int qc_getcontrast(const struct qcam *q)
+int
+qc_getcontrast (const struct qcam *q)
 {
   return q->contrast;
 }
 
-int qc_setcontrast(struct qcam *q, int val)
+int
+qc_setcontrast (struct qcam *q, int val)
 {
   if (val >= 0 && val <= 255) {
-    q->contrast=val;
+    q->contrast = val;
     return 0;
   }
   return 1;
@@ -99,15 +103,17 @@ int qc_setcontrast(struct qcam *q, int val)
 
 /* Gets/sets the white balance */
 
-int qc_getwhitebal(const struct qcam *q)
+int
+qc_getwhitebal (const struct qcam *q)
 {
   return q->whitebal;
 }
 
-int qc_setwhitebal(struct qcam *q, int val)
+int
+qc_setwhitebal (struct qcam *q, int val)
 {
   if (val >= 0 && val <= 255) {
-    q->whitebal=val;
+    q->whitebal = val;
     return 0;
   }
   return 1;
@@ -116,45 +122,51 @@ int qc_setwhitebal(struct qcam *q, int val)
 
 /* Gets/sets the resolution */
 
-void qc_getresolution(const struct qcam *q, int *x, int *y)
+void
+qc_getresolution (const struct qcam *q, int *x, int *y)
 {
-  *x=q->width;
-  *y=q->height;
+  *x = q->width;
+  *y = q->height;
 }
 
-int qc_setresolution(struct qcam *q, int x, int y)
+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;
+    q->width = x;
+    q->height = y;
     return 0;
   }
   return 1;
 }
 
-int qc_getheight(const struct qcam *q)
+int
+qc_getheight (const struct qcam *q)
 {
   return q->height;
 }
 
-int qc_setheight(struct qcam *q, int y)
+int
+qc_setheight (struct qcam *q, int y)
 {
   if (y >= 0 && y <= 243) {
-    q->height=y;
+    q->height = y;
     return 0;
   }
   return 1;
 }
 
-int qc_getwidth(const struct qcam *q)
+int
+qc_getwidth (const struct qcam *q)
 {
   return q->width;
 }
 
-int qc_setwidth(struct qcam *q, int x)
+int
+qc_setwidth (struct qcam *q, int x)
 {
   if (x >= 0 && x <= 336) {
-    q->width=x;
+    q->width = x;
     return 0;
   }
   return 1;
@@ -162,26 +174,30 @@ int qc_setwidth(struct qcam *q, int x)
 
 /* Gets/sets the bit depth */
 
-int qc_getbitdepth(const struct qcam *q)
+int
+qc_getbitdepth (const struct qcam *q)
 {
   return q->bpp;
 }
 
-int qc_setbitdepth(struct qcam *q, int val)
+int
+qc_setbitdepth (struct qcam *q, int val)
 {
   if (val == 4 || val == 6) {
-    q->bpp=val;
-    return qc_setscanmode(q);
+    q->bpp = val;
+    return qc_setscanmode (q);
   }
   return 1;
 }
 
-int qc_gettop(const struct qcam *q)
+int
+qc_gettop (const struct qcam *q)
 {
   return q->top;
 }
 
-int qc_settop(struct qcam *q, int val)
+int
+qc_settop (struct qcam *q, int val)
 {
   if (val >= 1 && val <= 243) {
     q->top = val;
@@ -190,12 +206,14 @@ int qc_settop(struct qcam *q, int val)
   return 1;
 }
 
-int qc_getleft(const struct qcam *q)
+int
+qc_getleft (const struct qcam *q)
 {
   return q->left;
 }
 
-int qc_setleft(struct qcam *q, int val)
+int
+qc_setleft (struct qcam *q, int val)
 {
   if (val % 2 == 0 && val >= 2 && val <= 336) {
     q->left = val;
@@ -204,22 +222,24 @@ int qc_setleft(struct qcam *q, int val)
   return 1;
 }
 
-int qc_gettransfer_scale(const struct qcam *q)
+int
+qc_gettransfer_scale (const struct qcam *q)
 {
   return q->transfer_scale;
 }
 
-int qc_settransfer_scale(struct qcam *q, int val)
+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 qc_setscanmode (q);
   }
   return 1;
 }
 
 int
-qc_calibrate(struct qcam *q)
+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 */
@@ -227,19 +247,21 @@ qc_calibrate(struct qcam *q)
 /* 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 */
+  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);
+    qc_command (q, 33);
+    value = qc_readparam (q);
 #ifdef DEBUG
     count++;
 #endif
@@ -248,15 +270,15 @@ qc_calibrate(struct qcam *q)
   q->whitebal = value;
 
 #ifdef DEBUG
-  fprintf(stderr, "%d loops to calibrate\n", count);
-  fprintf(stderr, "Calibrated to %d\n", value);
+  fprintf (stderr, "%d loops to calibrate\n", count);
+  fprintf (stderr, "Calibrated to %d\n", value);
 #endif
 
   return value;
 }
 
 int
-qc_forceunidir(struct qcam *q)
+qc_forceunidir (struct qcam *q)
 {
   q->port_mode = (q->port_mode & ~QC_FORCE_MASK) | QC_FORCE_UNIDIR;
   return 0;
@@ -266,29 +288,29 @@ qc_forceunidir(struct qcam *q)
 /* 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)
+qc_init (void)
 {
   struct qcam *q;
 
-  q=malloc(sizeof(struct qcam));
+  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->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->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)
-             */
+  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;
 }
@@ -301,21 +323,22 @@ qc_init(void)
  * Returns 0 for success, 1 for opening error, 2 for locking error,
  * and 3 for qcam not found */
 
-int qc_open(struct qcam *q)
+int
+qc_open (struct qcam *q)
 {
-  if(q->port==0)
-    if(qc_probe(q)) {
-      fprintf(stderr,"Qcam not found\n");
+  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");
+  if (qc_lock (q)) {
+    fprintf (stderr, "Cannot lock qcam.\n");
     return 2;
   }
 
-  if(enable_ports(q)) {
-    fprintf(stderr,"Cannot open QuickCam -- permission denied.");
+  if (enable_ports (q)) {
+    fprintf (stderr, "Cannot open QuickCam -- permission denied.");
     return 1;
   } else {
     return 0;
@@ -326,11 +349,12 @@ int qc_open(struct qcam *q)
 /* 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)
+int
+qc_close (struct qcam *q)
 {
-  qc_unlock(q);
+  qc_unlock (q);
 
-  disable_ports(q);
+  disable_ports (q);
   return 0;
 }
 
@@ -340,43 +364,46 @@ int qc_close(struct qcam *q)
  * 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)
+static int
+qc_command (const struct qcam *q, int command)
 {
   int n1, n2;
   int cmd;
 
-  write_lpdata(q, command);
-  write_lpcontrol(q,6);
+  write_lpdata (q, command);
+  write_lpcontrol (q, 6);
 
-  n1 = qc_waithand(q,1);
+  n1 = qc_waithand (q, 1);
 
-  write_lpcontrol(q,0xe);
-  n2 = qc_waithand(q,0);
+  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);
+    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");
+    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)
+qc_readparam (const struct qcam *q)
 {
   int n1, n2;
   int cmd;
 
-  write_lpcontrol(q,6);
-  n1 = qc_waithand(q,1);
+  write_lpcontrol (q, 6);
+  n1 = qc_waithand (q, 1);
 
-  write_lpcontrol(q,0xe);
-  n2 = qc_waithand(q,0);
+  write_lpcontrol (q, 0xe);
+  n2 = qc_waithand (q, 0);
 
   cmd = (n1 & 0xf0) | ((n2 & 0xf0) >> 4);
   return cmd;
@@ -385,16 +412,15 @@ qc_readparam(const struct qcam *q)
 /* 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)
+static int
+qc_waithand (const struct qcam *q, int val)
 {
   int status;
 
   if (val)
-    while(! ((status = read_lpstatus(q))&8))
-	;
+    while (!((status = read_lpstatus (q)) & 8));
   else
-    while (((status = read_lpstatus(q))&8))
-	;
+    while (((status = read_lpstatus (q)) & 8));
 
   return status;
 }
@@ -405,12 +431,13 @@ static int qc_waithand(const struct qcam *q, int val)
  * since this data is useful. */
 
 static unsigned int
-qc_waithand2(const struct qcam *q, int val)
+qc_waithand2 (const struct qcam *q, int val)
 {
   unsigned int status;
+
   do {
-    status = read_lpdata(q);
-  } while ( (status & 1) != val);
+    status = read_lpdata (q);
+  } while ((status & 1) != val);
 
   return status;
 }
@@ -423,27 +450,29 @@ qc_waithand2(const struct qcam *q, int val)
    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
+qc_detect (const struct qcam *q)
 {
-  int reg,lastreg;
-  int count=0;
+  int reg, lastreg;
+  int count = 0;
   int i;
 
-  lastreg=reg=read_lpstatus(q)&0xf0;
+  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);
+  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 */
+  if (count > 3 && count < 15)
+    return 1;			/* found */
+  else
+    return 0;			/* not found */
 }
 
 
@@ -452,10 +481,10 @@ int qc_detect(const struct qcam *q)
  * check that bi-directional mode is detected right, and then
  * implement bi-directional mode in qc_readbyte(). */
 
-void qc_reset(struct qcam *q)
+void
+qc_reset (struct qcam *q)
 {
-  switch (q->port_mode & QC_FORCE_MASK)
-  {
+  switch (q->port_mode & QC_FORCE_MASK) {
     case QC_FORCE_UNIDIR:
       q->port_mode = (q->port_mode & ~QC_MODE_MASK) | QC_UNIDIR;
       break;
@@ -465,10 +494,10 @@ void qc_reset(struct qcam *q)
       break;
 
     case QC_ANY:
-      write_lpcontrol(q,0x20);
-      write_lpdata(q,0x75);
+      write_lpcontrol (q, 0x20);
+      write_lpdata (q, 0x75);
 
-      if (read_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;
@@ -477,15 +506,15 @@ void qc_reset(struct qcam *q)
 
     case QC_FORCE_SERIAL:
     default:
-      fprintf(stderr, "Illegal port_mode %x\n", q->port_mode);
+      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 */
+  /* usleep(250); */
+  write_lpcontrol (q, 0xb);
+  usleep (250);
+  write_lpcontrol (q, 0xe);
+  (void) qc_setscanmode (q);	/* in case port_mode changed */
 }
 
 
@@ -498,28 +527,43 @@ void qc_reset(struct qcam *q)
  * returned.  If the scan is smaller, then the rest of the image
  * returned contains garbage. */
 
-static int qc_setscanmode(struct qcam *q)
+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;
+    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;
+    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;
+    case QC_BIDIR:
+      q->mode += 1;
+      break;
+    case QC_NOTSET:
+    case QC_UNIDIR:
+      break;
+    default:
+      return 1;
   }
   return 0;
 }
@@ -528,44 +572,51 @@ static int qc_setscanmode(struct qcam *q)
 /* Reset the QuickCam and program for brightness, contrast,
  * white-balance, and resolution. */
 
-void qc_set(struct qcam *q)
+void
+qc_set (struct qcam *q)
 {
   int val;
   int val2;
 
-  qc_reset(q);
+  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);
+  qc_command (q, 0xb);
+  qc_command (q, q->brightness);
 
   val = q->height / q->transfer_scale;
-  qc_command(q,0x11); qc_command(q, val);
+  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 */
+       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) *
+    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);
+  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, 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_command (q, 0x19);
+  qc_command (q, q->contrast);
+  qc_command (q, 0x1f);
+  qc_command (q, q->whitebal);
 }
 
 
@@ -573,9 +624,8 @@ void qc_set(struct qcam *q)
    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[])
+static int __inline__
+qc_readbytes (const struct qcam *q, char buffer[])
 {
   int ret;
   unsigned int hi, lo;
@@ -585,84 +635,90 @@ qc_readbytes(const struct qcam *q, char buffer[])
 
   if (buffer == NULL) {
     state = 0;
-    return 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;
+    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;
 }
@@ -679,7 +735,8 @@ qc_readbytes(const struct qcam *q, char buffer[])
  * n=2^(bit depth)-1.  Ask me for more details if you don't understand
  * this. */
 
-scanbuf *qc_scan(const struct qcam *q)
+scanbuf *
+qc_scan (const struct qcam * q)
 {
   unsigned char *ret;
   int i, j, k;
@@ -692,31 +749,32 @@ scanbuf *qc_scan(const struct qcam *q)
   char invert;
 
   if (q->mode != -1) {
-    qc_command(q, 0x7);
-    qc_command(q, q->mode);
+    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
-    */
+       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");
+    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);
+    (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);
+    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 */
@@ -725,23 +783,23 @@ scanbuf *qc_scan(const struct qcam *q)
   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;
+  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);
+  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);
+  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);
+      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);
@@ -750,18 +808,18 @@ scanbuf *qc_scan(const struct qcam *q)
 	     must be 0-15 -- bls */
 	  buffer[k] = 16;
 	}
-	ret[i*pixels_per_line + pixels_read + k] = invert - buffer[k];
+	ret[i * pixels_per_line + pixels_read + k] = invert - buffer[k];
       }
       pixels_read += bytes;
     }
-    (void) qc_readbytes(q, 0); /* reset state machine */
+    (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);
+    write_lpcontrol (q, 2);
+    write_lpcontrol (q, 6);
+    usleep (3);
+    write_lpcontrol (q, 0xe);
   }
 
   return ret;
@@ -769,24 +827,23 @@ scanbuf *qc_scan(const struct qcam *q)
 
 
 void
-qc_dump(const struct qcam *q, char *fname)
+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);
+  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);
+  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);
 }
diff --git a/sys/qcam/qcam-os.c b/sys/qcam/qcam-os.c
index e73933d9..2c959e72 100644
--- a/sys/qcam/qcam-os.c
+++ b/sys/qcam/qcam-os.c
@@ -48,22 +48,50 @@ OTHER DEALINGS IN THE SOFTWARE.
 #include "qcam.h"
 #include "qcam-Linux.h"
 
-int __inline__ read_lpstatus(const struct qcam *q) { return inb(q->port+1); }
-int read_lpcontrol(const struct qcam *q) { return inb(q->port+2); }
-int read_lpdata(const struct qcam *q) { return inb(q->port); }
-void write_lpdata(const struct qcam *q, int d) { outb(d,q->port); }
-void write_lpcontrol(const struct qcam *q, int d) { outb(d,q->port+2); }
+int __inline__
+read_lpstatus (const struct qcam *q)
+{
+  return inb (q->port + 1);
+}
+
+int
+read_lpcontrol (const struct qcam *q)
+{
+  return inb (q->port + 2);
+}
+
+int
+read_lpdata (const struct qcam *q)
+{
+  return inb (q->port);
+}
 
-int enable_ports(const struct qcam *q) 
+void
+write_lpdata (const struct qcam *q, int d)
 {
-  if(q->port<0x278) return 1; /* Better safe than sorry */
-  if(q->port>0x3bc) return 1; 
-  return (ioperm(q->port, 3, 1));
+  outb (d, q->port);
 }
 
-int disable_ports(const struct qcam *q)
+void
+write_lpcontrol (const struct qcam *q, int d)
 {
-  return (ioperm(q->port, 3, 0));
+  outb (d, q->port + 2);
+}
+
+int
+enable_ports (const struct qcam *q)
+{
+  if (q->port < 0x278)
+    return 1;			/* Better safe than sorry */
+  if (q->port > 0x3bc)
+    return 1;
+  return (ioperm (q->port, 3, 1));
+}
+
+int
+disable_ports (const struct qcam *q)
+{
+  return (ioperm (q->port, 3, 0));
 }
 
 /* Lock port.  This is currently sub-optimal, and is begging to be
@@ -81,121 +109,118 @@ int disable_ports(const struct qcam *q)
  * multiple processes (eg. qcam) taking "snapshots" can peacefully coexist.
  * - Dave Plonka (plonka@carroll1.cc.edu)
  */
-int qc_lock_wait(struct qcam *q, int wait)
+int
+qc_lock_wait (struct qcam *q, int wait)
 {
 #if 1
   static struct flock sfl;
 
-  if (-1 == q->fd) /* we've yet to open the lock file */
-  {
-     static char lockfile[128];
-
-     sprintf(lockfile,"/var/run/LOCK.qcam.0x%x",q->port);
-     if (-1 == (q->fd = open(lockfile, O_WRONLY | O_CREAT, 0666)))
-     {
-        perror("open");
-        return 1;
-     }
+  if (-1 == q->fd) {		/* we've yet to open the lock file */
+    static char lockfile[128];
 
+    sprintf (lockfile, "/var/run/LOCK.qcam.0x%x", q->port);
+    if (-1 == (q->fd = open (lockfile, O_WRONLY | O_CREAT, 0666))) {
+      perror ("open");
+      return 1;
+    }
 #ifdef TESTING
-     fprintf(stderr, "%s - %d: %s open(2)ed\n", __FILE__, __LINE__, lockfile);
+    fprintf (stderr, "%s - %d: %s open(2)ed\n", __FILE__, __LINE__, lockfile);
 #endif
 
-     /* initialize the l_type memver to lock the file exclusively */
-     sfl.l_type = F_WRLCK;
+    /* initialize the l_type memver to lock the file exclusively */
+    sfl.l_type = F_WRLCK;
   }
-
 #ifdef TESTING
-  if (0 != fcntl(q->fd, F_SETLK, &sfl)) /* non-blocking set lock */
+  if (0 != fcntl (q->fd, F_SETLK, &sfl))	/* non-blocking set lock */
 #else
-  if (0 != fcntl(q->fd, wait? F_SETLKW : F_SETLK, &sfl))
+  if (0 != fcntl (q->fd, wait ? F_SETLKW : F_SETLK, &sfl))
 #endif
   {
 #ifdef TESTING
-     perror("fcntl");
-     if (EAGAIN != errno || !wait) return 1;
-    
-     fprintf(stderr, "%s - %d: waiting for exclusive lock on fd %d...\n", __FILE__, __LINE__, q->fd);
+    perror ("fcntl");
+    if (EAGAIN != errno || !wait)
+      return 1;
+
+    fprintf (stderr, "%s - %d: waiting for exclusive lock on fd %d...\n",
+	__FILE__, __LINE__, q->fd);
 
-     if (0 != fcntl(q->fd, F_SETLKW, &sfl)) /* "blocking" set lock */
+    if (0 != fcntl (q->fd, F_SETLKW, &sfl))	/* "blocking" set lock */
 #endif
-     {
-        perror("fcntl");
-        return 1;
-     }
+    {
+      perror ("fcntl");
+      return 1;
+    }
   }
-
 #ifdef TESTING
-  fprintf(stderr, "%s - %d: fd %d locked exclusively\n", __FILE__, __LINE__, q->fd);
+  fprintf (stderr, "%s - %d: fd %d locked exclusively\n", __FILE__, __LINE__,
+      q->fd);
 #endif
 
 #else
   char lockfile[128], tmp[128];
   struct stat statbuf;
 
-  sprintf(lockfile,"/var/run/LOCK.qcam.0x%x",q->port);
-  sprintf(tmp,"%s-%d",lockfile,getpid());
+  sprintf (lockfile, "/var/run/LOCK.qcam.0x%x", q->port);
+  sprintf (tmp, "%s-%d", lockfile, getpid ());
 
-  if ((creat(tmp,0)==-1) || 
-      (link(tmp,lockfile)==-1) ||
-      (stat(tmp,&statbuf)==-1) || 
-      (statbuf.st_nlink==1))
-  {
+  if ((creat (tmp, 0) == -1) ||
+      (link (tmp, lockfile) == -1) ||
+      (stat (tmp, &statbuf) == -1) || (statbuf.st_nlink == 1)) {
 #ifdef DEBUGQC
-    perror("QuickCam Locked");
-    if(unlink(tmp)==-1)
-      perror("Error unlinking temp file.");
+    perror ("QuickCam Locked");
+    if (unlink (tmp) == -1)
+      perror ("Error unlinking temp file.");
 #else
-    unlink(tmp);
+    unlink (tmp);
 #endif
     return 1;
   }
-  
-  unlink(tmp);
-  if (chown(lockfile,getuid(),getgid())==-1)
-    perror("Chown problems");
+
+  unlink (tmp);
+  if (chown (lockfile, getuid (), getgid ()) == -1)
+    perror ("Chown problems");
 #endif
 
   return 0;
 }
 
-int qc_lock(struct qcam *q)
+int
+qc_lock (struct qcam *q)
 {
 #if 1
-   return qc_lock_wait(q, 1 /*wait*/);
+  return qc_lock_wait (q, 1 /*wait */ );
 #else
-   return qc_lock_wait(q, 0 /*don't wait*/);
+  return qc_lock_wait (q, 0 /*don't wait */ );
 #endif
 }
 
 /* Unlock port */
 
-int qc_unlock(struct qcam *q)
+int
+qc_unlock (struct qcam *q)
 {
   static struct flock sfl;
+
 #if 1
-  if (-1 == q->fd)
-  { /* port was not locked */
-     return 1;
+  if (-1 == q->fd) {		/* port was not locked */
+    return 1;
   }
 
   /* clear the exclusive lock */
   sfl.l_type = F_UNLCK;
-  if (0 != fcntl(q->fd, F_SETLK, &sfl))
-  {
-     perror("fcntl");
-     return 1;
+  if (0 != fcntl (q->fd, F_SETLK, &sfl)) {
+    perror ("fcntl");
+    return 1;
   }
-
 #ifdef TESTING
-  fprintf(stderr, "%s - %d: fd %d unlocked\n", __FILE__, __LINE__, q->fd);
+  fprintf (stderr, "%s - %d: fd %d unlocked\n", __FILE__, __LINE__, q->fd);
 #endif
 
 #else
   char lockfile[128];
 
-  sprintf(lockfile,"/var/run/LOCK.qcam.0x%x",q->port);
-  unlink(lockfile); /* What would I do with an error? */
+  sprintf (lockfile, "/var/run/LOCK.qcam.0x%x", q->port);
+  unlink (lockfile);		/* What would I do with an error? */
 #endif
 
   return 0;
@@ -205,28 +230,28 @@ int qc_unlock(struct qcam *q)
 /* Probe for camera.  Returns 0 if found, 1 if not found, sets
    q->port.*/
 
-int qc_probe(struct qcam *q)
+int
+qc_probe (struct qcam *q)
 {
-  int ioports[]={0x378, 0x278, 0x3bc,0};
-  int i=0;
+  int ioports[] = { 0x378, 0x278, 0x3bc, 0 };
+  int i = 0;
 
   /* Attempt to get permission to access IO ports.  Must be root */
 
-  while(ioports[i]!=0) {
-    q->port=ioports[i++];
+  while (ioports[i] != 0) {
+    q->port = ioports[i++];
 
-    if (qc_open(q)) {
-      perror("Can't get I/O permission");
-      exit(1);
+    if (qc_open (q)) {
+      perror ("Can't get I/O permission");
+      exit (1);
     }
 
-    if(qc_detect(q)) {
-      fprintf(stderr,"QuickCam detected at 0x%x\n",q->port);
-      qc_close(q);
-      return(0);
-    }
-    else
-    qc_close(q);
+    if (qc_detect (q)) {
+      fprintf (stderr, "QuickCam detected at 0x%x\n", q->port);
+      qc_close (q);
+      return (0);
+    } else
+      qc_close (q);
   }
 
   return 1;
@@ -240,10 +265,11 @@ usleep(0)'s, and that's too slow -- qc_start was taking over a second
 to run.  This seems to help, but if anyone has a good
 speed-independent pause routine, please tell me. -- Scott */
 
-void qc_wait(int val)
+void
+qc_wait (int val)
 {
   int i;
-  
-  while(val--)
-    for(i=0;i<50000;i++);
+
+  while (val--)
+    for (i = 0; i < 50000; i++);
 }
diff --git a/sys/qcam/qcam-os.h b/sys/qcam/qcam-os.h
index 46dcbe51..06c1cb20 100644
--- a/sys/qcam/qcam-os.h
+++ b/sys/qcam/qcam-os.h
@@ -28,5 +28,3 @@ ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 OTHER DEALINGS IN THE SOFTWARE.
 
 ******************************************************************/
-
-
diff --git a/sys/qcam/qcam.h b/sys/qcam/qcam.h
index 35b2dc26..4697befd 100644
--- a/sys/qcam/qcam.h
+++ b/sys/qcam/qcam.h
@@ -54,7 +54,8 @@ OTHER DEALINGS IN THE SOFTWARE.
 #define MAX_HEIGHT 243
 #define MAX_WIDTH 336
 
-struct qcam {
+struct qcam
+{
   int width, height;
   int bpp;
   int mode;
@@ -63,72 +64,72 @@ struct qcam {
   int port_mode;
   int transfer_scale;
   int top, left;
-  int fd; /* lock file descriptor
-           * It was, unfortunately, necessary to add this member to the
-           * struct qcam to conveniently implement POSIX fcntl-style locking.
-           * We need a seperate lock file for each struct qcam, for instance,
-           * if the same process (using qcam-lib) is accessing multiple
-           * QuickCams on (of course) multiple ports.
-           * - Dave Plonka (plonka@carroll1.cc.edu)
-           */
+  int fd;			/* lock file descriptor
+				 * It was, unfortunately, necessary to add this member to the
+				 * struct qcam to conveniently implement POSIX fcntl-style locking.
+				 * We need a seperate lock file for each struct qcam, for instance,
+				 * if the same process (using qcam-lib) is accessing multiple
+				 * QuickCams on (of course) multiple ports.
+				 * - Dave Plonka (plonka@carroll1.cc.edu)
+				 */
 };
 
 typedef unsigned char scanbuf;
 
 /* General QuickCam handling routines */
 
-int qc_getbrightness(const struct qcam *q);
-int qc_setbrightness(struct qcam *q, int val);
-int qc_getcontrast(const struct qcam *q);
-int qc_setcontrast(struct qcam *q, int val);
-int qc_getwhitebal(const struct qcam *q);
-int qc_setwhitebal(struct qcam *q, int val);
-void qc_getresolution(const struct qcam *q, int *x, int *y);
-int qc_setresolution(struct qcam *q, int x, int y);
-int qc_getbitdepth(const struct qcam *q);
-int qc_setbitdepth(struct qcam *q, int val);
-int qc_getheight(const struct qcam *q);
-int qc_setheight(struct qcam *q, int y);
-int qc_getwidth(const struct qcam *q);
-int qc_setwidth(struct qcam *q, int x);
-int qc_gettop(const struct qcam *q);
-int qc_settop(struct qcam *q, int val);
-int qc_getleft(const struct qcam *q);
-int qc_setleft(struct qcam *q, int val);
-int qc_gettransfer_scale(const struct qcam *q);
-int qc_settransfer_scale(struct qcam *q, int val);
-int qc_calibrate(struct qcam *q);
-int qc_forceunidir(struct qcam *q);
-void qc_dump(const struct qcam *q, char *file);
-
-struct qcam *qc_init(void);
-int qc_initfile(struct qcam *q, char *fname);
-int qc_open(struct qcam *q);
-int qc_close(struct qcam *q);
-int qc_detect(const struct qcam *q);
-void qc_reset(struct qcam *q);
-void qc_set(struct qcam *q);
-scanbuf *qc_scan(const struct qcam *q);
-scanbuf *qc_convertscan(struct qcam *q, scanbuf *scan);
-void qc_writepgm(const struct qcam *q, FILE *f, scanbuf *scan);
-void qc_wait(int val);
+int qc_getbrightness (const struct qcam *q);
+int qc_setbrightness (struct qcam *q, int val);
+int qc_getcontrast (const struct qcam *q);
+int qc_setcontrast (struct qcam *q, int val);
+int qc_getwhitebal (const struct qcam *q);
+int qc_setwhitebal (struct qcam *q, int val);
+void qc_getresolution (const struct qcam *q, int *x, int *y);
+int qc_setresolution (struct qcam *q, int x, int y);
+int qc_getbitdepth (const struct qcam *q);
+int qc_setbitdepth (struct qcam *q, int val);
+int qc_getheight (const struct qcam *q);
+int qc_setheight (struct qcam *q, int y);
+int qc_getwidth (const struct qcam *q);
+int qc_setwidth (struct qcam *q, int x);
+int qc_gettop (const struct qcam *q);
+int qc_settop (struct qcam *q, int val);
+int qc_getleft (const struct qcam *q);
+int qc_setleft (struct qcam *q, int val);
+int qc_gettransfer_scale (const struct qcam *q);
+int qc_settransfer_scale (struct qcam *q, int val);
+int qc_calibrate (struct qcam *q);
+int qc_forceunidir (struct qcam *q);
+void qc_dump (const struct qcam *q, char *file);
+
+struct qcam *qc_init (void);
+int qc_initfile (struct qcam *q, char *fname);
+int qc_open (struct qcam *q);
+int qc_close (struct qcam *q);
+int qc_detect (const struct qcam *q);
+void qc_reset (struct qcam *q);
+void qc_set (struct qcam *q);
+scanbuf *qc_scan (const struct qcam *q);
+scanbuf *qc_convertscan (struct qcam *q, scanbuf * scan);
+void qc_writepgm (const struct qcam *q, FILE * f, scanbuf * scan);
+void qc_wait (int val);
 
 /* OS/hardware specific routines */
 
-int read_lpstatus(const struct qcam *q);
-int read_lpcontrol(const struct qcam *q);
-int read_lpdata(const struct qcam *q);
-void write_lpdata(const struct qcam *q, int d);
-void write_lpcontrol(const struct qcam *q, int d);
-int enable_ports(const struct qcam *q);
-int disable_ports(const struct qcam *q);
-int qc_unlock(struct qcam *q);
-int qc_lock(struct qcam *q);
-void qc_wait(int val);
-int qc_probe(struct qcam *q);
+int read_lpstatus (const struct qcam *q);
+int read_lpcontrol (const struct qcam *q);
+int read_lpdata (const struct qcam *q);
+void write_lpdata (const struct qcam *q, int d);
+void write_lpcontrol (const struct qcam *q, int d);
+int enable_ports (const struct qcam *q);
+int disable_ports (const struct qcam *q);
+int qc_unlock (struct qcam *q);
+int qc_lock (struct qcam *q);
+void qc_wait (int val);
+int qc_probe (struct qcam *q);
 
 /* Image processing routines */
-int fixdark(const struct qcam *q, scanbuf *scan);
-int qc_edge_detect(const struct qcam *q, scanbuf *scan, int tolerance);
+int fixdark (const struct qcam *q, scanbuf * scan);
+int qc_edge_detect (const struct qcam *q, scanbuf * scan, int tolerance);
 
-#endif /*! _QCAM_H*/
+#endif /*! _QCAM_H */
diff --git a/sys/qcam/qcamip.h b/sys/qcam/qcamip.h
index 3bab6faf..e3bc5c2e 100644
--- a/sys/qcam/qcamip.h
+++ b/sys/qcam/qcamip.h
@@ -55,13 +55,13 @@ SOFTWARE.
 
 /* Prototypes for image processing routines  */
 
-int qcip_autoexposure(struct qcam *q, scanbuf *scan);
-int qcip_set_luminance_target(struct qcam *q, int val);
-int qcip_set_luminance_tolerance(struct qcam *q, int val);
-int qcip_set_luminance_std_target(struct qcam *q, int val);
-int qcip_set_luminance_std_tolerance(struct qcam *q, int val);
-int qcip_set_autoexposure_mode(int val);
-void qcip_histogram(struct qcam *q, scanbuf *scan, int *histogram);
-void qcip_display_histogram(struct qcam *q, scanbuf *scan);
+int qcip_autoexposure (struct qcam *q, scanbuf * scan);
+int qcip_set_luminance_target (struct qcam *q, int val);
+int qcip_set_luminance_tolerance (struct qcam *q, int val);
+int qcip_set_luminance_std_target (struct qcam *q, int val);
+int qcip_set_luminance_std_tolerance (struct qcam *q, int val);
+int qcip_set_autoexposure_mode (int val);
+void qcip_histogram (struct qcam *q, scanbuf * scan, int *histogram);
+void qcip_display_histogram (struct qcam *q, scanbuf * scan);
 
-#endif /*! _QCAMIP_H*/
+#endif /*! _QCAMIP_H */
-- 
cgit v1.2.1