import java.awt.Dimension;
import java.awt.image.BufferedImage;
import java.io.BufferedOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Vector;
 
import javax.imageio.ImageIO;
import javax.media.Buffer;
import javax.media.CannotRealizeException;
import javax.media.CaptureDeviceInfo;
import javax.media.CaptureDeviceManager;
import javax.media.Format;
import javax.media.Manager;
import javax.media.MediaLocator;
import javax.media.NoDataSourceException;
import javax.media.NoPlayerException;
import javax.media.Player;
import javax.media.control.FrameGrabbingControl;
import javax.media.format.RGBFormat;
import javax.media.format.VideoFormat;
import javax.media.protocol.CaptureDevice;
import javax.media.protocol.DataSource;
import javax.media.util.BufferToImage;
 
/**
 * A disposable class that uses JMF to serve a still sequence captured from a
 * webcam over a socket connection. It doesn't use TCP, it just blindly captures
 * a still, JPEG compresses it, and pumps it out over any incoming socket
 * connection.
 * 
 * @author Tom Gibara
 * 
 */
 
public class WebcamBroadcaster {
 
        public static boolean RAW = false;
 
        private static Player createPlayer(int width, int height) {
                try {
                        Vector<CaptureDeviceInfo> devices = CaptureDeviceManager.getDeviceList(null);
                        for (CaptureDeviceInfo info : devices) {
 
                                Format[] formats = info.getFormats();
                                for (Format format : formats) {
                                        if (!(format instanceof RGBFormat))
                                                continue;
                                        RGBFormat rgb = (RGBFormat) format;
                                        Dimension size = rgb.getSize();
                                        if (size.width != width || size.height != height)
                                                continue;
                                        if (rgb.getPixelStride() != 3)
                                                continue;
                                        if (rgb.getBitsPerPixel() != 24)
                                                continue;
                                        if (rgb.getLineStride() != width * 3)
                                                continue;
                                        MediaLocator locator = info.getLocator();
                                        DataSource source = Manager.createDataSource(locator);
                                        source.connect();
                                        System.out.println("Done");
                                        ((CaptureDevice) source).getFormatControls()[0]
                                                        .setFormat(rgb);
                                        return Manager.createRealizedPlayer(source);
                                }
                        }
                } catch (IOException e) {
                        e.printStackTrace();
                } catch (NoPlayerException e) {
                        e.printStackTrace();
                } catch (CannotRealizeException e) {
                        e.printStackTrace();
                } catch (NoDataSourceException e) {
                        e.printStackTrace();
                }
                return null;
        }
 
        public static void main(String[] args) {
                int[] values = new int[args.length];
                for (int i = 0; i < values.length; i++) {
                        values[i] = Integer.parseInt(args[i]);
                }
 
 
 
                WebcamBroadcaster wb;
                if (values.length == 0) {
                        wb = new WebcamBroadcaster();
                } else if (values.length == 1) {
                        wb = new WebcamBroadcaster(values[0]);
                } else if (values.length == 2) {
                        wb = new WebcamBroadcaster(values[0], values[1]);
                } else {
                        wb = new WebcamBroadcaster(values[0], values[1], values[2]);
                }
 
                wb.start();
        }
 
        public static final int DEFAULT_PORT = 9889;
        public static final int DEFAULT_WIDTH = 320;
        public static final int DEFAULT_HEIGHT = 240;
 
        private final Object lock = new Object();
 
        private final int width;
        private final int height;
        private final int port;
 
        private boolean running;
 
        private Player player;
        private FrameGrabbingControl control;
        private boolean stopping;
        private Worker worker;
 
        public WebcamBroadcaster(int width, int height, int port) {
                this.width = width;
                this.height = height;
                this.port = port;
        }
 
        public WebcamBroadcaster(int width, int height) {
                this(width, height, DEFAULT_PORT);
        }
 
        public WebcamBroadcaster(int port) {
                this(DEFAULT_WIDTH, DEFAULT_HEIGHT, port);
        }
 
        public WebcamBroadcaster() {
                this(DEFAULT_WIDTH, DEFAULT_HEIGHT, DEFAULT_PORT);
        }
 
        public void start() {
                synchronized (lock) {
                        if (running)
                                return;
                        player = createPlayer(width, height);
                        if (player == null) {
                                System.err.println("Unable to find a suitable player");
                                return;
                        }
                        player.start();
                        control = (FrameGrabbingControl) player
                                        .getControl("javax.media.control.FrameGrabbingControl");
                        worker = new Worker();
                        worker.start();
                        running = true;
                }
        }
 
        public void stop() throws InterruptedException {
                synchronized (lock) {
                        if (!running)
                                return;
                        if (player != null) {
                                control = null;
                                player.stop();
                                player = null;
                        }
                        stopping = true;
                        running = false;
                        worker = null;
                }
                try {
                        worker.join();
                } finally {
                        stopping = false;
                }
        }
 
        private class Worker extends Thread {
 
                private final int[] data = new int[width * height];
 
                @Override
                public void run() {
                        ServerSocket ss;
                        try {
                                ss = new ServerSocket(port);
 
                        } catch (IOException e) {
                                e.printStackTrace();
                                return;
                        }
 
                        while (true) {
                                FrameGrabbingControl c;
                                synchronized (lock) {
                                        if (stopping)
                                                break;
                                        c = control;
                                }
                                Socket socket = null;
                                try {
                                        socket = ss.accept();
 
                                        Buffer buffer = c.grabFrame();
                                        BufferToImage btoi = new BufferToImage((VideoFormat) buffer
                                                        .getFormat());
                                        BufferedImage image = (BufferedImage) btoi
                                                        .createImage(buffer);
 
                                        if (image != null) {
                                                OutputStream out = socket.getOutputStream();
                                                if (RAW) {
                                                        image.getWritableTile(0, 0).getDataElements(0, 0,
                                                                        width, height, data);
                                                        image.releaseWritableTile(0, 0);
                                                        DataOutputStream dout = new DataOutputStream(
                                                                        new BufferedOutputStream(out));
                                                        for (int i = 0; i < data.length; i++) {
                                                                dout.writeInt(data[i]);
                                                        }
                                                        dout.close();
                                                } else {
                                                        ImageIO.write(image, "JPEG", out);
                                                }
                                        }
 
                                        socket.close();
                                        socket = null;
                                } catch (IOException e) {
                                        e.printStackTrace();
                                } finally {
                                        if (socket != null)
                                                try {
                                                        socket.close();
                                                } catch (IOException e) {
                                                        /* ignore */
                                                }
                                }
 
                        }
 
                        try {
                                ss.close();
                        } catch (IOException e) {
                                /* ignore */
                        }
                }
 
        }
 
}
 

private static Player createPlayer(int width, int height) {
        try {
            Vector<CaptureDeviceInfo> devices = CaptureDeviceManager.getDeviceList(null);
            for (CaptureDeviceInfo info : devices) {
 
                Format[] formats = info.getFormats();
                for (Format format : formats) {
                    if (!(format instanceof YUVFormat)) {
                        continue;
                    }
                    //RGBFormat rgb = (RGBFormat) format;
 
                    YUVFormat YUV = (YUVFormat)format;
                    //Dimension size = rgb.getSize();
 
                    Dimension size =YUV.getSize();
                    if (size.width != width || size.height != height) {
                        continue;
                    }
                   // if(YUV.get)
                   // if (rgb.getPixelStride() != 3) {
                    //    continue;
                   // }
                   // if (rgb.getBitsPerPixel() != 24) {
                     //   continue;
                   // }
                  //  if (rgb.getLineStride() != width * 3) {
                    //    continue;
                  //  }
                    MediaLocator locator = info.getLocator();
                    DataSource source = Manager.createDataSource(locator);
                    source.connect();
                    System.out.println("XD");
                    ((CaptureDevice) source).getFormatControls()[0].setFormat(YUV);
                    return Manager.createRealizedPlayer(source);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (NoPlayerException e) {
            e.printStackTrace();
        } catch (CannotRealizeException e) {
            e.printStackTrace();
        } catch (NoDataSourceException e) {
            e.printStackTrace();
        }
        return null;
    }