Java

import javax.swing.*;
import javax.swing.event.*;
import java.io.*;
import javax.media.*;
import javax.media.format.*;
import javax.media.util.*;
import javax.media.control.*;
import javax.media.protocol.*;
import java.util.*;
import java.awt.*;
import java.awt.image.*;
import java.awt.event.*;
import com.sun.image.codec.jpeg.*;

import javax.imageio.ImageIO; 
import java.awt.image.BufferedImage;

public class Web extends Panel implements ActionListener 
{
  public static Player player = null;
  public CaptureDeviceInfo di = null;
  public MediaLocator ml = null;
  public JButton capture1 = null;
  public Buffer buf = null;
  public Image img = null;
  public VideoFormat vf = null;
  public BufferToImage btoi = null;
  public ImagePanel imgpanel = null;
  public MediaLocator dl;
  String destinationName = null;
  public double duration = 10;
  public int waitFor = 0;
  public Vector devices;
  public static final Format VIDEO_FORMAT = new VideoFormat(VideoFormat.CINEPAK);
  public Location2Location capture;
  public Format[] formats = new Format[1];
  public ContentDescriptor videoContainer = new ContentDescriptor(FileTypeDescriptor.MSVIDEO);
  public ContentDescriptor container = null;
	
//    public boolean useKnownDevices = false;
	
 
  public Web() 
  {
    setLayout(new BorderLayout());
    setSize(320,550);
 
    imgpanel = new ImagePanel();
    capture1 = new JButton("Capture1");
    capture1.addActionListener(this);
 
    String str1 = "vfw:Logitech USB Video Camera:0";
    String str2 = "vfw:Microsoft WDM Image Capture (Win32):0";
    di = CaptureDeviceManager.getDevice(str2);
    ml = new MediaLocator("vfw://0");
    
    String DEFAULT_VIDEO_NAME = "captured.avi";
	String VIDEO = "video";
	String selected = VIDEO;
	
 	//ml = di.getLocator();
	formats[0] = VIDEO_FORMAT;
	if (destinationName==null)
	destinationName = DEFAULT_VIDEO_NAME;
	container = videoContainer;
	
	
	
	dl = new MediaLocator(destinationName);
		System.out.println("Configuring for capture. Please wait.");
		capture = new Location2Location(ml,
		dl,formats,container,1.0);
		
		System.out.println("Started recording " + duration +
		" seconds of " + selected + " ...");
		capture.setStopTime(new Time(duration));
		if (waitFor==0)
		waitFor = (int)(4000*duration);
		else
		waitFor *= 1000;
		int waited = capture.transfer(waitFor);
		

		int state = capture.getState();
		if (state==Location2Location.FINISHED)
		System.out.println(selected + " capture successful " +
		"in approximately " + ((int)((waited+500)/1000)) +
		" seconds. Data written to " + destinationName);
		else if (state==Location2Location.FAILED)
		System.out.println(selected + " capture failed " +
		"after approximately " + ((int)((waited+500)/1000)) +
		" seconds");
		else {
		System.out.println(selected + " capture still ongoing " +
		"after approximately " + ((int)((waited+500)/1000)) +
		" seconds");
		System.out.println("Process likely to have failed");
		}
		
		System.exit(0);	

Location2Location(MediaLocator sourceLocation,
MediaLocator destinationLocation, Format[] outputFormats,
ContentDescriptor outputContainer, double rate) {

//////////////////////////////////////////////
// Construct the processor for the transcoding
//////////////////////////////////////////////
state = TRANSLATING;
sinkLocation = destinationLocation;
try {
if (sourceLocation==null)
model = new ProcessorModel(outputFormats,outputContainer);
else
model = new ProcessorModel(sourceLocation,
outputFormats,outputContainer);
processor = Manager.createRealizedProcessor(model);
}
catch (Exception e) {
state = FAILED;
return;
}

translationRate = processor.setRate((float)Math.abs(rate));
processor.addControllerListener(this);

////////////////////////////////////////////////////////////
// Construct the DataSink and employ an anonymous class as
// a DataSink listener in order that the end of transfer
// (completion of task) can be detected.
///////////////////////////////////////////////////////////
source = processor.getDataOutput();
try {
sink = Manager.createDataSink(source,sinkLocation);
}
catch (Exception sinkException) {
state = FAILED;
processor.removeControllerListener(this);
processor.close();
processor = null;
return;
}
sink.addDataSinkListener(new DataSinkListener() {
public void dataSinkUpdate(DataSinkEvent e) {
if (e instanceof EndOfStreamEvent) {
sink.close();
source.disconnect();
if (state!=FAILED)
state = FINISHED;
}
else if (e instanceof DataSinkErrorEvent) {
if (sink!=null)
sink.close();
if (source!=null)
source.disconnect();
state = FAILED;
}
}
});
// Start the transcoding
processor.start();
}


/***************************************************************
* Alternate constructor: source and destination specified as
* Strings, and no rate provided (hence rate of 1.0)
****************************************************************/
Location2Location(String sourceName, String destinationName,
Format[] outputFormats, ContentDescriptor outputContainer) {

this(new MediaLocator(sourceName), new MediaLocator(destinationName),
outputFormats, outputContainer);
}


/****************************************************************
* Alternate constructor: No rate specified therefore rate of 1.0
*****************************************************************/
Location2Location(MediaLocator sourceLocation,
MediaLocator destinationLocation, Format[] outputFormats,
ContentDescriptor outputContainer) {

this(sourceLocation,destinationLocation,outputFormats,outputContainer,1.0f);
}


/***************************************************************
* Alternate constructor: source and destination specified as
* Strings.
****************************************************************/
Location2Location(String sourceName, String destinationName,
Format[] outputFormats, ContentDescriptor outputContainer,
double rate) {

this(new MediaLocator(sourceName), new MediaLocator(destinationName),
outputFormats, outputContainer, rate);
}


public synchronized void controllerUpdate(ControllerEvent e) {

if (state==FAILED)
return;

// Transcoding complete.
if (e instanceof StopEvent) {
processor.removeControllerListener(this);
processor.close();
if (state==TRANSLATING)
state = TRANSFERRING;
}
// Transcoding failed.
else if (e instanceof ControllerErrorEvent) {
processor.removeControllerListener(this);
processor.close();
state = FAILED;
}
}

public int transfer(int timeOut) {

// Can't initiate: Processor already failed to transcode
////////////////////////////////////////////////////////
if (state==FAILED)
return -1;

// Start the DataSink
//////////////////////
try {
sink.open();
sink.start();
}
catch (Exception e) {
state = FAILED;
return -1;
}
if (state==TRANSLATING)
state = TRANSFERRING;
if (timeOut<=0)
return timeOut;

// Wait till the process is complete, failed, or the
// prescribed time has passed.
/////////////////////////////////////////////////////
int waited = 0;
while (state!=FAILED && state!=FINISHED && waited<timeOut) {
try { Thread.sleep(WAIT_PERIOD); }
catch (InterruptedException ie) { }
waited += WAIT_PERIOD;
}
return waited;
}