import javax.media.Processor; //导入依赖的package包/类
public boolean configure(int timeOutMillis) {
long startTime = System.currentTimeMillis();
synchronized (this) {
    if (player instanceof Processor)
	 ((Processor)player).configure();
    else
	 return false;

    while (!configured && !failed) {
	 try {
	     wait(timeOutMillis);
	 } catch (InterruptedException ie) {
	 }
	 if (System.currentTimeMillis() - startTime > timeOutMillis)
	     break;
    }
}
return configured;
  }
 

import javax.media.Processor; //导入依赖的package包/类
/**
    * Create the DataSink.
    */
   DataSink createDataSink(Processor p, MediaLocator outML) {

DataSource ds;

if ((ds = p.getDataOutput()) == null) {
    System.err.println("Something is really wrong: the processor does not have an output DataSource");
    return null;
}

DataSink dsink;

try {
    System.err.println("- create DataSink for: " + outML);
    dsink = Manager.createDataSink(ds, outML);
    dsink.open();
} catch (Exception e) {
    System.err.println("Cannot create the DataSink: " + e);
    return null;
}

return dsink;
   }
 

import javax.media.Processor; //导入依赖的package包/类
/****************************************************************
    * Boring methods of SuperGlueDataSource
    ****************************************************************/
   

   private synchronized boolean waitForState(Processor p, int state) {
StateListener sl = new StateListener();
p.addControllerListener(sl);
failed = false;

if (state == Processor.Configured) {
    p.configure();
} else if (state == Processor.Realized) {
    p.realize();
}

while (p.getState() < state && !failed) {
    synchronized (getStateLock()) {
	try {
	    getStateLock().wait();
	} catch (InterruptedException ie) {
	    return false;
	}
    }
}	
p.removeControllerListener(sl);
return !failed;
   }
 

import javax.media.Processor; //导入依赖的package包/类
private synchronized boolean waitForState(Processor p, int state) {
StateListener sl = new StateListener();
p.addControllerListener(sl);
failed = false;

if (state == Processor.Configured) {
    p.configure();
} else if (state == Processor.Realized) {
    p.realize();
}

while (p.getState() < state && !failed) {
    synchronized (getStateLock()) {
	try {
	    getStateLock().wait();
	} catch (InterruptedException ie) {
	    return false;
	}
    }
}	
p.removeControllerListener(sl);
return !failed;
   }
 

import javax.media.Processor; //导入依赖的package包/类
/**
 * 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) {
		processor.setMediaTime(Processor.RESET);
		processor.start();
		//processor.close();
		//System.exit(0);
	}
}
 

import javax.media.Processor; //导入依赖的package包/类
/**
    * 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;
   }
 

import javax.media.Processor; //导入依赖的package包/类
private synchronized boolean waitForState(Processor p, int state) {
p.addControllerListener(new StateListener());
failed = false;

// Call the required method on the processor
if (state == Processor.Configured) {
    p.configure();
} else if (state == Processor.Realized) {
    p.realize();
}

// Wait until we get an event that confirms the
// success of the method, or a failure event.
// See StateListener inner class
while (p.getState() < state && !failed) {
    synchronized (getStateLock()) {
	try {
	    getStateLock().wait();
	} catch (InterruptedException ie) {
	    return false;
	}
    }
}

if (failed)
    return false;
else
    return true;
   }
 

import javax.media.Processor; //导入依赖的package包/类
/**
 * Blocks until the processor has transitioned to the given state. Return false
 * if the transition failed.
 */
private boolean waitForState(Processor p, int state) throws InterruptedException
{
	synchronized (waitSync)
	{
		while (p.getState() < state && stateTransitionOK)
		{
			waitSync.wait();
		}
	}
	return stateTransitionOK;
}
 

import javax.media.Processor; //导入依赖的package包/类
private synchronized boolean waitForState(Processor p, int state) {
    p.addControllerListener(new StateListener());
    failed = false;

    // Call the required method on the processor
    if (state == Processor.Configured) {
        p.configure();
    }
    else if (state == Processor.Realized) {
        p.realize();
    }

    // Wait until we get an event that confirms the
    // success of the method, or a failure event.
    // See StateListener inner class
    while (p.getState() < state && !failed) {
        synchronized (getStateLock()) {
            try {
                getStateLock().wait();
            }
            catch (InterruptedException ie) {
                return false;
            }
        }
    }

    return !failed;
}
 

import javax.media.Processor; //导入依赖的package包/类
public void process(String recordingFile, String movieFile) throws Exception {

      MediaLocator mediaLocator = new MediaLocator(new File(movieFile).toURI()
            .toURL());
      PlayerDataSource playerDataSource = new PlayerDataSource(recordingFile);
      Processor processor = Manager.createProcessor(playerDataSource);
      processor.addControllerListener(this);
      processor.configure();

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

      processor.setContentDescriptor(new ContentDescriptor(
            FileTypeDescriptor.QUICKTIME));

      TrackControl trackControl[] = processor.getTrackControls();
      Format format[] = trackControl[0].getSupportedFormats();
      trackControl[0].setFormat(format[0]);
      processor.realize();
      if (!waitForState(processor, Processor.Realized)) {
         System.err.println("Failed to realize the processor.");
         return;
      }

      DataSource dataSource = processor.getDataOutput();
      DataSink dataSink = Manager.createDataSink(dataSource, mediaLocator);
      dataSink.open();
      processor.start();
      dataSink.start();
      waitForFileDone();
      dataSink.close();
      processor.removeControllerListener(this);
   }
 

import javax.media.Processor; //导入依赖的package包/类
boolean waitForState(Processor p, int state) {
   synchronized (waitSync) {
      try {
         while (p.getState() < state && stateTransitionOK)
            waitSync.wait();
      } catch (Exception e) {
      }
   }
   return stateTransitionOK;
}
 

import javax.media.Processor; //导入依赖的package包/类
protected synchronized boolean waitForState(Processor p, int state) {
	p.addControllerListener(new StateListener());
	failed = false;

	// Call the required method on the processor
	if (state == Processor.Configured) {
		p.configure();
	} else if (state == Processor.Realized) {
		p.realize();
	}

	// Wait until we get an event that confirms the
	// success of the method, or a failure event.
	// See StateListener inner class
	while (p.getState() < state && !failed) {
		synchronized (getStateLock()) {
			try {
				getStateLock().wait();
			} catch (InterruptedException ie) {
				return false;
			}
		}
	}

	if (failed)
		return false;
	else
		return true;
}
 

import javax.media.Processor; //导入依赖的package包/类
public boolean waitForState(Processor p, int state) {
    synchronized (waitSync) {
        try {
            while (p.getState() < state) {
                waitSync.wait();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    return p.getState() == state;
}
 

import javax.media.Processor; //导入依赖的package包/类
private synchronized boolean waitForState(Processor p, int state) {
    p.addControllerListener(new StateListener());
    failed = false;

    // Call the required method on the processor
    if (state == Processor.Configured) {
        p.configure();
    } else if (state == Processor.Realized) {
        p.realize();
    }

    // Wait until we get an event that confirms the
    // success of the method, or a failure event.
    // See StateListener inner class
    while (p.getState() < state && !failed) {
        synchronized (getStateLock()) {
            try {
                getStateLock().wait();
            } catch (InterruptedException ie) {
                return false;
            }
        }
    }

    if (failed)
        return false;
    else
        return true;
}
 

import javax.media.Processor; //导入依赖的package包/类
public void actionPerformed(ActionEvent ae) {

	String mediaFile1 = vcPanel1.getMediaFile();
	String mediaFile2 = vcPanel2.getMediaFile();
	Time beginTime1 = vcPanel1.getBeginTime();
	Time beginTime2 = vcPanel2.getBeginTime();
	Time endTime1 = vcPanel1.getEndTime();
	Time endTime2 = vcPanel2.getEndTime();

	String sDuration = (String) cbDuration.getSelectedItem();
	long duration = (long) Integer.parseInt(sDuration) * 1000000000L;
	vcPanel3.setURL(null);
	if (mediaFile1 == null || mediaFile2 == null ||
	    beginTime1 == null || beginTime2 == null ||
	    endTime1 == null || endTime2 == null)
	    return;

	vcPanel1.stop();
	vcPanel2.stop();
	SuperGlueDataSource sgds = new SuperGlueDataSource(
				    new String [] { mediaFile1, mediaFile2 },
				    new Time [] { beginTime1, beginTime2 },
				    new Time [] { endTime1, endTime2 },
				    new Time [] { new Time(duration), new Time(duration) },
				    new String[] { (String) cbEffect.getSelectedItem() },
				    new String[0],
				    new Dimension(160, 120));
	buttonGo.setEnabled(false);
	try {
	    sgds.connect();
	    sgds.setProgressListener(this);
	    Processor p = Manager.createProcessor(sgds);
	    boolean success = waitForState(p, Processor.Configured);

	    if (!success) {
		System.err.println("Error configuring output processor");
		buttonGo.setEnabled(true);
		return;
	    }

	    p.setContentDescriptor(new FileTypeDescriptor(FileTypeDescriptor.QUICKTIME));
	    success = waitForState(p, Processor.Realized);
	    if (!success) {
		System.err.println("Could not realize output processor");
		buttonGo.setEnabled(true);
	    }
	    DataSource ds = p.getDataOutput();
	    doSave(p, ds);
	} catch (Exception ex) {
	    buttonGo.setEnabled(true);
	    System.err.println("Exception creating processor: " + ex);
	}
    }
 

import javax.media.Processor; //导入依赖的package包/类
public EOMListener(Processor p) {
    this.p = p;
}
 

import javax.media.Processor; //导入依赖的package包/类
public boolean isOpen() {
	return (processor != null && processor.getState() == Processor.Started);
}
 

import javax.media.Processor; //导入依赖的package包/类
public Processor getProcessor(){
	return p;
}
 

import javax.media.Processor; //导入依赖的package包/类
private static void test(File file, AviVideoFormat format) throws IOException, NoProcessorException, NoDataSinkException {
    System.out.println("* Writing " + file);
    DataSource source = new ImageDataSource(format);
    Processor p = Manager.createProcessor(source);
    Handler h = new Handler();
    p.addControllerListener(h);
    p.configure();
    if (!h.waitForState(p, Processor.Configured)) {
        throw new IOException("Could not configure processor.");
    }
    p.setContentDescriptor(new ContentDescriptor(FileTypeDescriptor.MSVIDEO));
    TrackControl trackControls[] = p.getTrackControls();
    javax.media.Format formats[] = trackControls[0].getSupportedFormats();
    if (formats == null || formats.length <= 0) {
        throw new UnsupportedOperationException("No output formats available.");
    }
    String encoding = format.getEncoding();
    javax.media.Format selectedFormat = null;
    for (javax.media.Format f : formats) {
        if (f.getEncoding().equals(encoding)) {
            selectedFormat = f;
            break;
        }
    }
    if (selectedFormat == null) {
        throw new UnsupportedOperationException("No output format selected.");
    }
    trackControls[0].setFormat(selectedFormat);
    p.realize();
    if (!h.waitForState(p, Processor.Realized)) {
        throw new IOException("Could not realize processor.");
    }
    MediaLocator ml = new MediaLocator(file.toURI().toURL());
    DataSink sink = Manager.createDataSink(p.getDataOutput(), ml);
    sink.addDataSinkListener(h);
    sink.open();
    try {
        sink.start();
        p.start();
        if (!h.waitForEndOfMedia()) {
            throw new IOException("Processor reported an error.");
        }
        p.stop();
        sink.stop();
        /*
        if (!h.waitForFileDone()) {
        throw new IOException("DataSink reported an error.");
        }*/
    } finally {
        p.close();
        sink.close();
    }
}
 

import javax.media.Processor; //导入依赖的package包/类
public void waitUntilDone() throws InterruptedException{
	while (processor.getState() != Processor.Prefetched) {
		Thread.sleep(100);
	}
}