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 display selected RGB and YUV channels.
 * Author : Dr Mike Spann
 */


public class MovieFrameRGBtoYUVApplet 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;

	MyFrame3 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 MyFrame3(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);

		JMenuBar menuBar = new JMenuBar();
		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]);
		}
	  	menuBar.add(loadMenu);
		setJMenuBar(menuBar);
	}
}

class MyFrame3 extends JInternalFrame implements ControllerListener,ActionListener
{

	MediaLocator ml;

	Processor p;
    Processor p1;

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

	JButton[] buttons;

	JButton quitButton=new JButton("Quit");

	JPanel channelButton1Panel;
	JPanel channelButton2Panel;


	public MyFrame3(MediaLocator _ml, Processor _p, Processor _p1)
	{
		super("Video channel selector",true,true,true,true);

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


		// Add the slider for selecting the threshold

		getContentPane().setLayout(new BorderLayout());
		setLocation(50, 50);

		String[] buttonString={"R","G","B","Y","U","V"};
		buttons=new JButton[6];

		channelButton1Panel=new JPanel();
		channelButton1Panel.add(quitButton);
		quitButton.addActionListener(this);


		channelButton2Panel=new JPanel();


		for (int j=0; j<6; j++)
		{
			buttons[j]=new JButton(buttonString[j]);
			channelButton2Panel.add(buttons[j]);
		}


		setVisible(true);

		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 {
				FrameChannelSelect fcs=new FrameChannelSelect(0);
				Codec codec[] = { fcs };
		    	videoTrack.setCodecChain(codec);

		    	FrameChannelSelect fcs1=new FrameChannelSelect(1);
				for (int j=0; j<6; j++)
					buttons[j].addActionListener(fcs1);

				Codec codec1[] = { fcs1 };
		    	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;

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

		JPanel frame1Panel=new JPanel();
		frame1Panel.setLayout(new BorderLayout());

		JPanel frame2Panel=new JPanel();
		frame2Panel.setLayout(new BorderLayout());

		if ((vc = p.getVisualComponent()) != null)
	    	frame1Panel.add("Center",vc);

		frame1Panel.add("South",channelButton1Panel);

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

		if ((vc1 = p1.getVisualComponent()) != null)
		    frame2Panel.add("Center",vc1);

		frame2Panel.add("South",channelButton2Panel);

		framePanel.add(frame1Panel);
		framePanel.add(frame2Panel);

		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;
    }

	/**
	* Action Listener.
    */
	public void actionPerformed(ActionEvent evt)
   	{
		Object source = (JButton)evt.getSource();
		if (source==quitButton)
		{
			if (p!=null)
			{
				p.removeControllerListener(this);
				p.close();
			}
			try
			{
				setClosed(true);
			}
			catch (Exception e)
			{}
		}
	}

    /**
     * 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 FrameChannelSelect implements Effect, ActionListener
{
    Format inputFormat;
    Format outputFormat;
    Format[] inputFormats;
    Format[] outputFormats;

    private int processorID;

    private double[] rgbMult={0,0,0};

    public FrameChannelSelect(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;
        }


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

            	ip = lineStrideIn * y + x * pixStrideIn;

            	int grey=0;

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

					int intOffset=0;
					if ((rgbMult[0]<0)||(rgbMult[1]<0)||(rgbMult[2]<0))
						intOffset=128;

					if ((rgbMult[0]*rgbMult[1]*rgbMult[2])!=0)
					{
						int outVal=(int)(b*rgbMult[0]+g*rgbMult[1]+r*rgbMult[2]);
						outVal+=intOffset;
						outData[op++] = (byte)(outVal);
						outData[op++] = (byte)(outVal);
			        	outData[op++] = (byte)(outVal);
					}
					else
					{
						outData[op++] = (byte)(rgbMult[0]*b);
				    	outData[op++] = (byte)(rgbMult[1]*g);
			        	outData[op++] = (byte)(rgbMult[2]*r);
					}
				}
        	}


       	return BUFFER_PROCESSED_OK;

    }


	// method for ActionListener interface
	public void actionPerformed(ActionEvent evt)
	{
		JButton b=(JButton)evt.getSource();
		String channel=b.getText();
		if (channel.charAt(0)=='R')
		{
			rgbMult[0]=0; rgbMult[1]=0; rgbMult[2]=1;
		}
		else if (channel.charAt(0)=='G')
		{
			rgbMult[0]=0; rgbMult[1]=1; rgbMult[2]=0;
		}
		else if (channel.charAt(0)=='B')
		{
			rgbMult[0]=1; rgbMult[1]=0; rgbMult[2]=0;
		}
		else if (channel.charAt(0)=='Y')
		{
			rgbMult[0]=0.114; rgbMult[1]=0.587; rgbMult[2]=0.299;
		}
		else if (channel.charAt(0)=='U')
		{
			rgbMult[0]=0.5; rgbMult[1]=-0.331; rgbMult[2]=-0.169;
		}
		else if (channel.charAt(0)=='V')
		{
			rgbMult[0]=-0.081; rgbMult[1]=-0.419; rgbMult[2]=0.5;

		}

	}

    // 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;
    }


}