moving the libraries

processing/video/Camera.java

@@ -0,0 +1,473 @@
+/* -*- mode: jde; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+
+/*
+  Camera - whatchin shit on tv
+  Part of the Processing project - http://processing.org
+
+  Copyright (c) 2004-05 Ben Fry and Casey Reas
+  The previous version of this code was developed by Hernando Barragan
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General
+  Public License along with this library; if not, write to the
+  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+  Boston, MA  02111-1307  USA
+*/
+
+package processing.video;
+import processing.core.*;
+
+import java.lang.reflect.*;
+
+import quicktime.*;
+import quicktime.qd.*;
+import quicktime.std.*;
+import quicktime.std.sg.*;
+import quicktime.util.RawEncodedImage;
+
+
+public class Camera extends PImage
+implements StdQTConstants, StdQTConstants4, Runnable {
+  PApplet parent;
+  Method cameraEventMethod;
+  String name; // keep track for error messages
+  Thread runner;
+
+  //PImage borderImage;
+  //boolean removeBorders = true;
+  boolean available = false;
+
+  /** Temporary storage for the raw image data read directly from the camera */
+  public int data[];
+
+  public int dataWidth;
+  public int dataHeight;
+  public int dataRowBytes;
+
+  public boolean crop;
+  public int cropX;
+  public int cropY;
+  public int cropW;
+  public int cropH;
+
+  int fps;
+  RawEncodedImage raw;
+  SequenceGrabber capture;
+
+  static {
+    //System.out.println("Camera init");
+    try {
+      QTSession.open();
+    } catch (QTException e) {
+      e.printStackTrace();
+    }
+    QTRuntimeException.registerHandler(new QTRuntimeHandler() {
+        public void exceptionOccurred(QTRuntimeException e,
+                                      Object obj, String s, boolean flag) {
+          System.err.println("Problem inside Camera");
+          e.printStackTrace();
+        }
+      });
+  }
+
+
+  public Camera(PApplet parent, int requestWidth, int requestHeight) {
+    this(parent, "", requestWidth, requestHeight, 30);
+  }
+
+  public Camera(PApplet parent, int reqWidth, int reqHeight, int fps) {
+    this(parent, "", reqWidth, reqHeight, fps);
+  }
+
+  public Camera(PApplet parent, String name, int reqWidth, int reqHeight) {
+    this(parent, name, reqWidth, reqHeight, 30);
+  }
+
+
+  /*
+   quicktime.QTSession.open();
+  quicktime.std.sg.SequenceGrabber sg = new quicktime.std.sg.SequenceGrabber();
+  quicktime.std.sg.SGVideoChannel sc  = new quicktime.std.sg.SGVideoChannel(sg);
+  quicktime.std.sg.VideoDigitizer vd  = sc.getDigitizerComponent();
+  println( "dv.getNumberOfInputs :" ); println( vd.getNumberOfInputs() ); println();
+//change line below to set input source
+  vd.setInput(1);
+//
+  println( "dv.getInput :" ); println( vd.getInput() ); println();
+  } catch (Exception e) {
+  e.printStackTrace();
+  }
+  */
+
+  /**
+   * If 'name' is the empty string, don't set a specific device,
+   * which means that QuickTime will use that last device used by
+   * a QuickTime application. If name is set to null, a prompt
+   * will show up, allowing the user to choose the good stuff.
+   * <P>
+   * If the following function:
+   * public void cameraEvent(Camera c)
+   * is defined int the host PApplet, then it will be called every
+   * time a new frame is available from the camera.
+   */
+  public Camera(PApplet parent, String name,
+                int requestWidth, int requestHeight, int fps) {
+    this.parent = parent;
+    this.name = name;
+    this.fps = fps;
+
+    try {
+      /*
+      QTSession.open();
+      QTRuntimeException.registerHandler(new QTRuntimeHandler() {
+          public void exceptionOccurred(QTRuntimeException e,
+                                        Object obj, String s, boolean flag) {
+            System.err.println("Problem inside Camera");
+            e.printStackTrace();
+          }
+        });
+      */
+      //System.out.println("0");
+
+      QDRect qdrect = new QDRect(requestWidth, requestHeight);
+      QDGraphics qdgraphics = new QDGraphics(qdrect);
+
+      //System.out.println("0a");
+
+      capture = new SequenceGrabber();
+      //System.out.println("0b");
+      capture.setGWorld(qdgraphics, null);
+
+      //System.out.println("0c");
+
+      // CRASHING HERE ON OSX
+      SGVideoChannel channel = new SGVideoChannel(capture);
+      //System.out.println("0c1");
+      channel.setBounds(qdrect);
+      //System.out.println("0c2");
+      channel.setUsage(2);  // what is this usage number?
+      //System.out.println("0c3");
+      capture.startPreview();  // maybe this comes later?
+
+      //System.out.println("0d");
+
+      PixMap pixmap = qdgraphics.getPixMap();
+      raw = pixmap.getPixelData();
+
+      //System.out.println("0e");
+
+      if (name == null) {
+        channel.settingsDialog();
+
+      } else if (name.length() > 0) {
+        channel.setDevice(name);
+      }
+      //System.out.println("0f");
+      //channel.setDevice("Logitech QuickCam Express-WDM");
+      /*
+      if (showDialog) channel.settingsDialog();
+      SGDeviceList list = channel.getDeviceList(0);
+      System.out.println("count is " + list.getCount());
+      for (int i = 0; i < list.getCount(); i++) {
+        System.out.println(list.getDeviceName(i).getName());
+      }
+      //System.out.println(channel.getSettings());
+      */
+
+      //int grabWidthBytes = raw.getRowBytes();
+      dataRowBytes = raw.getRowBytes();
+      dataWidth = dataRowBytes / 4;
+
+      //System.out.println("row bytes " + raw.getRowBytes() + " " +
+      //                 (raw.getRowBytes() / 4));
+      //int extraBytes = dataRowBytes - requestWidth*4;
+      //int extraPixels = extraBytes / 4;
+      //int videoWidth = requestWidth + extraPixels;
+      dataHeight = raw.getSize() / dataRowBytes;
+
+      //System.out.println("height req, actual: " + requestHeight +
+      //                 " " + dataHeight);
+
+      if (dataWidth != requestWidth) {
+        crop = true;
+        cropX = 0;
+        cropY = 0;
+        cropW = requestWidth;
+        cropH = requestHeight;
+
+        /*
+        System.out.println("dataWidth is " + dataWidth +
+                           " not " + requestWidth);
+        if (removeBorders) {
+          int bpixels[] = new int[dataWidth * requestHeight];
+          borderImage = new PImage(bpixels, dataWidth, requestHeight, RGB);
+        } else {
+          requestWidth = dataWidth;
+        }
+        */
+      }
+      // initialize my PImage self
+      super.init(requestWidth, requestHeight, RGB);
+
+      runner = new Thread(this);
+      runner.start();
+
+      parent.registerDispose(this);
+
+      try {
+        cameraEventMethod =
+          parent.getClass().getMethod("cameraEvent",
+                                      new Class[] { Camera.class });
+      } catch (Exception e) {
+        // no such method, or an error.. which is fine, just ignore
+        //e.printStackTrace();
+      }
+
+    } catch (StdQTException qte) {
+      //qte.printStackTrace();
+
+      int errorCode = qte.errorCode();
+      // where's the friggin constant for this?
+      if (errorCode == -9405) {
+        // this can happen when the camera isn't available or
+        // wasn't shut down properly
+        parent.die("The camera (or VDIG) is not " +
+                   "installed correctly (see readme.txt).", qte);
+      } else {
+        parent.die("Error while setting up Camera", qte);
+      }
+    } catch (Exception e) {
+      parent.die("Error while setting up Camera", e);
+    }
+  }
+
+
+  /**
+   * True if a frame is ready to be read. Example:
+   * if (camera.available()) camera.read();
+   * <P>
+   * Alternatively, you can use cameraEvent(Camera c) to notify you
+   * whenever available() is set to true.
+   */
+  public boolean available() {
+    return available;
+  }
+
+
+  /**
+   * Set the video to crop from its original.
+   * <P>
+   * It seems common that cameras add lines to the top or bottom
+   * of an image, so this can be useful for removing them.
+   * Internally, the pixel buffer size returned from QuickTime is
+   * often a different size than requested, so crop will be set
+   * more often than not.
+   */
+  public void crop(int x, int y, int w, int h) {
+    if (imageMode == CORNERS) {
+      w -= x;  // w was actually x2
+      h -= y;  // h was actually y2
+    }
+
+    crop = true;
+    cropX = Math.max(0, x);
+    cropY = Math.max(0, y);
+    cropW = Math.min(w, dataWidth);
+    cropH = Math.min(dataHeight, y + h) - cropY;
+
+    // if size has changed, re-init this image
+    if ((cropW != width) || (cropH != height)) {
+      init(w, h, RGB);
+    }
+  }
+
+
+  public void noCrop() {
+    crop = false;
+  }
+
+
+  public void read() {
+    //try {
+    //synchronized (capture) {
+    synchronized (pixels) {
+      //long t1 = System.currentTimeMillis();
+
+      if (crop) {
+        /*
+        // f#$)(#$ing quicktime / jni is so g-d slow that this
+        // code takes literally 100x longer to run
+        int sourceOffset = cropX*4 + cropY*dataRowBytes;
+        int destOffset = 0;
+        for (int y = 0; y < cropH; y++) {
+          raw.copyToArray(sourceOffset, pixels, destOffset, cropW);
+          sourceOffset += dataRowBytes;
+          destOffset += width;
+        }
+        */
+        if (data == null) {
+          data = new int[dataWidth * dataHeight];
+        }
+        raw.copyToArray(0, data, 0, dataWidth * dataHeight);
+        int sourceOffset = cropX + cropY*dataWidth;
+        int destOffset = 0;
+        for (int y = 0; y < cropH; y++) {
+          System.arraycopy(data, sourceOffset, pixels, destOffset, cropW);
+          sourceOffset += dataWidth;
+          destOffset += width;
+        }
+
+        /*
+      if (borderImage != null) {  // need to remove borders
+        raw.copyToArray(0, borderImage.pixels,
+                        0, borderImage.width * borderImage.height);
+        int borderIndex = 0;
+        int targetIndex = 0;
+        for (int i = 0; i < height; i++) {
+          System.arraycopy(borderImage.pixels, borderIndex,
+                           pixels, targetIndex, width);
+            borderIndex += borderImage.width;
+            targetIndex += width;
+        }
+        */
+      } else {  // just copy directly
+        raw.copyToArray(0, pixels, 0, width * height);
+      }
+      //long t2 = System.currentTimeMillis();
+      //System.out.println(t2 - t1);
+
+      available = false;
+      // mark this image as modified so that PGraphics2 and PGraphicsGL
+      // willproperly re-blit and draw this guy
+      updatePixels();
+    }
+  }
+
+
+  public void run() {
+    while ((Thread.currentThread() == runner) && (capture != null)) {
+      try {
+        synchronized (capture) {
+          capture.idle();
+          //read();
+          available = true;
+
+          if (cameraEventMethod != null) {
+            try {
+              cameraEventMethod.invoke(parent, new Object[] { this });
+            } catch (Exception e) {
+              System.err.println("Disabling cameraEvent() for " + name +
+                                 " because of an error.");
+              e.printStackTrace();
+              cameraEventMethod = null;
+            }
+          }
+        }
+
+      } catch (QTException e) {
+        errorMessage("run", e);
+      }
+
+      try {
+        Thread.sleep(1000 / fps);
+      } catch (InterruptedException e) { }
+    }
+  }
+
+
+  /**
+   * Set the framerate for how quickly new frames are read
+   * from the camera.
+   */
+  public void framerate(int ifps) {
+    if (ifps <= 0) {
+      System.err.println("Camera: ignoring bad framerate of " +
+                         ifps + " fps.");
+      return;
+    }
+    fps = ifps;
+  }
+
+
+  /**
+   * Called by applets to stop capturing video.
+   */
+  public void stop() {
+    if (capture != null) {
+      try {
+        capture.stop(); // stop the "preview"
+      } catch (StdQTException e) {
+        e.printStackTrace();
+      }
+      capture = null;
+    }
+    runner = null; // unwind the thread
+  }
+
+
+  /**
+   * Called by PApplet to shut down video so that QuickTime
+   * can be used later by another applet.
+   */
+  public void dispose() {
+    stop();
+    //System.out.println("calling dispose");
+    // this is important so that the next app can do video
+    QTSession.close();
+  }
+
+
+  /**
+   * General error reporting, all corraled here just in case
+   * I think of something slightly more intelligent to do.
+   */
+  protected void errorMessage(String where, Exception e) {
+    parent.die("Error inside Camera." + where + "()", e);
+  }
+
+
+  /**
+   * Shows the settings dialog for this channel.
+   */
+  //public void prompt() {
+  //channel.settingsDialog();
+  //}
+
+
+  /**
+   * Get a list of all available cameras as a String array.
+   * i.e. printarr(Camera.list()) will show you the goodies.
+   */
+  static public String[] list() {
+    try {
+      SequenceGrabber grabber = new SequenceGrabber();
+      SGVideoChannel channel = new SGVideoChannel(grabber);
+
+      //VideoDigitizer digitizer = channel.getDigitizerComponent();
+      //digitizer.setInput(2); // or something
+      //DigitizerInfo di = digitizer.getDigitizerInfo()
+
+      SGDeviceList deviceList = channel.getDeviceList(0);  // flags is 0
+      String listing[] = new String[deviceList.getCount()];
+      for (int i = 0; i < deviceList.getCount(); i++) {
+        listing[i] = deviceList.getDeviceName(i).getName();
+      }
+      // properly shut down the channel so the app can use it again
+      grabber.disposeChannel(channel);
+      return listing;
+
+    } catch (QTException e) {
+      e.printStackTrace();
+    }
+    return null;
+  }
+}