import java.applet.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;
import javax.media.*;
import javax.media.control.TrackControl;
import javax.media.Format;
import javax.media.format.*;
import java.net.*;


/**
 * Sample program to test the video frame difference.
 * Author : Dr Mike Spann
 */


public class MovieFrameDifferenceApplet extends JApplet implements ActionListener
{

	String sequenceFilename=null;

public static final String[] sequenceList={"Face.avi","Movement.avi","Walk1.avi",
                                           "CorridorScene1.avi","ShopScene1.avi"};

	JMenuItem[] openItem;

	JDesktopPane desktop=null;

	MyFrame2 f=null;

	Processor p=null;
	Processor p1=null;


	public void actionPerformed(ActionEvent evt)
   	{
		Object source = evt.getSource();

		for (int i=0; i<sequenceList.length; i++)
      	{
      		if (source == openItem[i])
      		{
				MediaLocator ml=null;
				try
				{
					String sequenceFilename=sequenceList[i];
					String url=(new URL(getDocumentBase(),sequenceFilename)).toExternalForm();
					System.out.println("url= " + url);

					ml=new MediaLocator(url);

					System.out.println("ml= " + ml);


					if (ml  == null)
					{
			    		System.err.println("Cannot build media locator from: " + url);
			    		return;
					}
				}
				catch (Exception e)
				{}

		        f = new MyFrame2(ml,p,p1);
	    		desktop.add(f);

			}
      	}
	}


    /**
     * init
    */
    public void init()
    {

		// Add the desktop pane
		getContentPane().setLayout( new BorderLayout() );
		desktop = new JDesktopPane();
		desktop.setDoubleBuffered(true);
		getContentPane().add("Center", desktop);
		setVisible(true);

		JMenu loadMenu = new JMenu("Load sequence");
		openItem=new JMenuItem[sequenceList.length];
		for (int i=0; i<sequenceList.length; i++)
		{
			openItem[i]=new JMenuItem(sequenceList[i]);
			openItem[i].addActionListener(this);
			loadMenu.add(openItem[i]);
		}

		JMenuBar menuBar = new JMenuBar();
      	menuBar.add(loadMenu);
      	setJMenuBar(menuBar);
	}
}

class MyFrame2 extends JInternalFrame implements ControllerListener
{

	MediaLocator ml;

	Processor p;
    Processor p1;

    Object waitSync = new Object();
    boolean stateTransitionOK = true;

	JPanel framePanel;

	JSlider slider=new JSlider(0,255,0); // For setting the threshold

	public MyFrame2(MediaLocator _ml, Processor _p, Processor _p1)
	{
		super("Video frame difference thresholder",true,true,true,true);

		ml=_ml;
		p=_p;
		p1=_p1;

     	// Add the slider for selecting the threshold

		getContentPane().setLayout(new BorderLayout());
		slider.setPaintLabels(true);
		slider.setPaintTicks(true);
		slider.setMajorTickSpacing(16);
		getContentPane().add("North", slider);
		setLocation(50, 50);

		setVisible(true);

		framePanel=new JPanel();
		framePanel.setLayout(new GridLayout(1,2,5,5));

		if (!open(ml))
			System.out.println("Couldn't open " + ml);
	}


	/**
     * Given a media locator, create a processor and use that processor
     * as a player to playback the media.
     *
     *
     * Much of the code is just standard code to present media in JMF.
    */
	public boolean open(MediaLocator ml)
	{
		if (p!=null)
		{
			p.removeControllerListener(this);
			p.stop();
			p.close();
		}
		if (p1!=null)
		{
			p1.removeControllerListener(this);
			p1.stop();
			p1.close();
		}

		try
		{
	    	p=Manager.createProcessor(ml);
	    	p1=Manager.createProcessor(ml);
		} catch (Exception e)
		{
	    	System.err.println("Failed to create a processor from the given url: " + e);
	    	return false;
		}

		p.addControllerListener(this);
		p1.addControllerListener(this);


		// Put the Processor into configured state.
		p.configure();
		if (!waitForState(p,p.Configured))
		{
	    	System.err.println("Failed to configure the processor.");
	    	return false;
		}

		p1.configure();
		if (!waitForState(p1,p1.Configured))
		{
		    System.err.println("Failed to configure the processor.");
		    return false;
		}

		// So I can use it as a player.

		p.setContentDescriptor(null);
		p1.setContentDescriptor(null);

		// Obtain the track controls.
		TrackControl tc[] = p.getTrackControls();

		TrackControl tc1[] = p1.getTrackControls();

		if ((tc == null)||(tc1==null))
		{
	    	System.err.println("Failed to obtain track controls from the processors.");
	    	return false;
		}

		// Search for the track control for the video track.
		TrackControl videoTrack = null;
		TrackControl videoTrack1 = null;

		for (int i = 0; i < tc.length; i++)
		{
	    	if (tc[i].getFormat() instanceof VideoFormat)
	    	{
				videoTrack = tc[i];
				break;
	    	}
		}

		for (int i = 0; i < tc1.length; i++)
		{
	    	if (tc1[i].getFormat() instanceof VideoFormat)
	    	{
				videoTrack1 = tc1[i];
				break;
			}
		}

		if ((videoTrack == null)||(videoTrack1==null))
		{
	    	System.err.println("The input media does not contain a video track.");
	    	return false;
		}


		// Instantiate and set the frame access codec to the data flow path.
		try {
				FrameDifference tt=new FrameDifference(0);
				slider.addChangeListener(tt);
				Codec codec[] = { tt };
		    	videoTrack.setCodecChain(codec);

		    	FrameDifference tt1=new FrameDifference(1);
				slider.addChangeListener(tt1);
				Codec codec1[] = { tt1 };
		    	videoTrack1.setCodecChain(codec1);
		}
		catch (UnsupportedPlugInException e)
		{
		    System.err.println("The processor does not support effects.");
		}

	 	p1.realize();

		if (!waitForState(p1,p1.Realized))
		{
			 System.err.println("Failed to realize the processor p1.");
			 return false;
		}

		p.realize();


		if (!waitForState(p,p.Realized))
		{
			    System.err.println("Failed to realize the processor.");
			    return false;
		}


		try {
				p.addController(p1);
			}
		catch (Exception e)
			{
				System.err.println("Failed to add a synchronised processor" + e);
				return false;
			}

		Component cc;

		Component vc,vc1;

		if ((vc = p.getVisualComponent()) != null)
	    	framePanel.add(vc);

		Dimension size = vc.getPreferredSize();
		int videoWidth = size.width;
		int videoHeight = size.height;

		if ((vc1 = p1.getVisualComponent()) != null)
		    framePanel.add(vc1);

		getContentPane().add("Center",framePanel);

		if ((cc = p.getControlPanelComponent()) != null)
	    	getContentPane().add("South", cc);

		int controlHeight = cc.getPreferredSize().height;

		int spaceWidth=5;

		setSize(2*videoWidth+spaceWidth, videoHeight+controlHeight);


		// Start the master processor.

		p.start();

		setVisible(true);

		pack();

		addInternalFrameListener( new InternalFrameAdapter()
		{
	    	public void internalFrameClosing(InternalFrameEvent ife)
	    	{
				System.out.println("Window closing event");
				p.close();
	    	}
		} );


		return true;

	}

	/**
     * Block until the processor has transitioned to the given state.
     * Return false if the transition failed.
    */
    boolean waitForState(Processor p, int state)
    {
		synchronized (waitSync)
		{
	    	try
	    	{
				while (p.getState() != state && stateTransitionOK)
		    	waitSync.wait();
	    	} catch (Exception e) {}
		}

		return stateTransitionOK;
    }


    /**
     * Controller Listener.
    */
    public void controllerUpdate(ControllerEvent evt)
    {

		if (evt instanceof ConfigureCompleteEvent ||
	    evt instanceof RealizeCompleteEvent ||
	    evt instanceof PrefetchCompleteEvent)
	    {
	    	synchronized (waitSync)
	    	{
				stateTransitionOK = true;
				waitSync.notifyAll();
	    	}
		}
		else if (evt instanceof ResourceUnavailableEvent)
		{
	    	synchronized (waitSync)
	    	{
				stateTransitionOK = false;
				waitSync.notifyAll();
	    	}
		}
		else if (evt instanceof EndOfMediaEvent)
		{
			p.setMediaTime(new Time(0));
	    	p.start();
		}
    }

}

class FrameDifference implements Effect, ChangeListener
{
    Format inputFormat;
    Format outputFormat;
    Format[] inputFormats;
    Format[] outputFormats;

    byte[] previousFrameData=null;

    byte[] currentFrameData=null;

    int processorID;
    int threshold=0;
    int frameNumber=0;

    public FrameDifference(int id)
    {

        processorID=id;

        inputFormats = new Format[]
        {
            new RGBFormat(null,
                          Format.NOT_SPECIFIED,
                          Format.byteArray,
                          Format.NOT_SPECIFIED,
                          24,
                          3, 2, 1,
                          3, Format.NOT_SPECIFIED,
                          Format.TRUE,
                          Format.NOT_SPECIFIED)
        };

        outputFormats = new Format[]
        {
            new RGBFormat(null,
                          Format.NOT_SPECIFIED,
                          Format.byteArray,
                          Format.NOT_SPECIFIED,
                          24,
                          3, 2, 1,
                          3, Format.NOT_SPECIFIED,
                          Format.TRUE,
                          Format.NOT_SPECIFIED)
        };

    }

    // methods for interface Codec
    public Format[] getSupportedInputFormats()
    {
		return inputFormats;
    }

    public Format [] getSupportedOutputFormats(Format input)
    {
        if (input == null)
            return outputFormats;

        if (matches(input, inputFormats) != null)
        {
            return new Format[] { outputFormats[0].intersects(input) };
        }
        else
        {
            return new Format[0];
        }
    }

    public Format setInputFormat(Format input)
    {
		inputFormat = input;
		return input;
    }

    public Format setOutputFormat(Format output)
    {
        if (output == null || matches(output, outputFormats) == null)
            return null;
        RGBFormat incoming = (RGBFormat) output;

        Dimension size = incoming.getSize();
        int maxDataLength = incoming.getMaxDataLength();
        int lineStride = incoming.getLineStride();
        float frameRate = incoming.getFrameRate();
        int flipped = incoming.getFlipped();
        int endian = incoming.getEndian();

        if (size == null)
            return null;
        if (maxDataLength < size.width * size.height * 3)
            maxDataLength = size.width * size.height * 3;
        if (lineStride < size.width * 3)
            lineStride = size.width * 3;
        if (flipped != Format.FALSE)
            flipped = Format.FALSE;

        outputFormat = outputFormats[0].intersects(new RGBFormat(size,
                                                        maxDataLength,
                                                        null,
                                                        frameRate,
                                                        Format.NOT_SPECIFIED,
                                                        Format.NOT_SPECIFIED,
                                                        Format.NOT_SPECIFIED,
                                                        Format.NOT_SPECIFIED,
                                                        Format.NOT_SPECIFIED,
                                                        lineStride,
                                                        Format.NOT_SPECIFIED,
                                                        Format.NOT_SPECIFIED));

        return outputFormat;
    }


    public int process(Buffer inBuffer, Buffer outBuffer)
    {

        int outputDataLength = ((VideoFormat)outputFormat).getMaxDataLength();
        validateByteArraySize(outBuffer, outputDataLength);

        outBuffer.setLength(outputDataLength);
        outBuffer.setFormat(outputFormat);
        outBuffer.setFlags(inBuffer.getFlags());

        byte [] inData = (byte[]) inBuffer.getData();
        byte [] outData = (byte[]) outBuffer.getData();


		RGBFormat vfIn = (RGBFormat) inBuffer.getFormat();
        Dimension sizeIn = vfIn.getSize();
        int pixStrideIn = vfIn.getPixelStride();
        int lineStrideIn = vfIn.getLineStride();

        int iw = sizeIn.width;
        int ih = sizeIn.height;
        int ip = 0;
        int op = 0;

        if ( outData.length < iw*ih*3 )
        {
            System.out.println("the buffer is not full");
            return BUFFER_PROCESSED_FAILED;
        }

        if (frameNumber==0)
          previousFrameData=new byte[3*iw*ih];


		if (frameNumber!=0)
        	for ( int y=0; y < ih; y++ )
            	for ( int x=0; x < iw; x++ )
            	{

            		ip = lineStrideIn * y + x * pixStrideIn;

            		int greyDiff=0;
            		int g1=0;
            		int g2=0;

            		if (processorID==0)
            		{
               			outData[op++] = inData[ip++];
              			outData[op++] = inData[ip++];
              			outData[op++] = inData[ip++];
					}
               		else
               		{
						g1=(0xff&inData[ip]);	// byte to int conversion
						g2=(0xff&previousFrameData[ip++]);

						greyDiff+=(Math.abs(g1-g2));

						g1=(0xff&inData[ip]);	// byte to int conversion
						g2=(0xff&previousFrameData[ip++]);
						greyDiff+=(Math.abs(g1-g2));

						g1=(0xff&inData[ip]);	// byte to int conversion
						g2=(0xff&previousFrameData[ip++]);
						greyDiff+=(Math.abs(g1-g2));

						greyDiff/=3;
						int binVal=0;
						if (greyDiff>threshold)
						  binVal=255;

				    	outData[op++] = (byte)binVal;
				    	outData[op++] = (byte)binVal;
			        	outData[op++] = (byte)binVal;

					}
        		}

        if (processorID!=0)	// Copy the previous frame data
			System.arraycopy(inData,0,previousFrameData,0,pixStrideIn*iw*ih);


		frameNumber++;

       	return BUFFER_PROCESSED_OK;

    }

    // method for the ChangeListner interface
    public void stateChanged(ChangeEvent e)
	{
		JSlider s=(JSlider)e.getSource();
		threshold=s.getValue();
	}

    // methods for interface PlugIn
    public String getName()
    {
        return "Video Frame Threshold";
    }

    public void open() {}

    public void close() {}

    public void reset() {}


    // methods for interface javax.media.Controls
    public Object getControl(String controlType)
    {
		return null;
    }

    public Object[] getControls()
    {
		return null;
    }


    // Utility methods.
    Format matches(Format in, Format outs[])
    {
		for (int i = 0; i < outs.length; i++)
		{
	    	if (in.matches(outs[i]))
				return outs[i];
		}

		return null;
    }

	byte[] validateByteArraySize(Buffer buffer,int newSize)
	{
        Object objectArray=buffer.getData();
        byte[] typedArray;

        if (objectArray instanceof byte[])
        {     // is correct type AND not null
            typedArray=(byte[])objectArray;
            if (typedArray.length >= newSize )
            { // is sufficient capacity
                return typedArray;
            }

            byte[] tempArray=new byte[newSize];  // re-alloc array
            System.arraycopy(typedArray,0,tempArray,0,typedArray.length);
            typedArray = tempArray;
        }
        else
        {
            typedArray = new byte[newSize];
        }

        buffer.setData(typedArray);
        return typedArray;
    }


}