import javax.media.protocol.ContentDescriptor; //导入依赖的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.protocol.ContentDescriptor; //导入依赖的package包/类
@Override
public void controllerUpdate(ControllerEvent p0) {
	if (p0 instanceof ConfigureCompleteEvent) {
		ContentDescriptor cd = new ContentDescriptor(
				ContentDescriptor.RAW_RTP);
		processor.setContentDescriptor(cd);
		Format format;
		TrackControl track[] = processor.getTrackControls();
		int numPistas=track.length;
		for(int i=0;i<numPistas;i++){
			format = track[i].getFormat();

			if (format instanceof VideoFormat) {
				VideoFormat v = (VideoFormat) track[i].getFormat();
				setMyVideoFormat(v, track[i]);
			}
			if (format instanceof AudioFormat) {
				AudioFormat a = (AudioFormat) track[i].getFormat();
				setMyAudioFormat(a, track[i]);
			}
		}
		processor.realize();
	}

	if (p0 instanceof RealizeCompleteEvent) {
		try {
			ds = processor.getDataOutput();
			createMyRTPManager();
		} catch (NotRealizedError ex) {
			myEx(null, ex.getMessage());
		}
	}

	if (p0 instanceof EndOfMediaEvent) {
		closeMyStream();
		endofMedia = true;
	}
}
 

import javax.media.protocol.ContentDescriptor; //导入依赖的package包/类
public PullSourceStream[] getStreams() {
	PullSourceStream [] streams = new PullSourceStream [1];
	InputSourceStream iss = new InputSourceStream(in, 
			new FileTypeDescriptor(ContentDescriptor.RAW));
	streams[0] = iss;
	return streams;
}
 

import javax.media.protocol.ContentDescriptor; //导入依赖的package包/类
@Override
public ContentDescriptor[] getSupportedInputContentDescriptors()
{
	return supportedInputContentDescriptors;
}
 

import javax.media.protocol.ContentDescriptor; //导入依赖的package包/类
public ContentDescriptor [] getSupportedInputContentDescriptors() {
    return supportedFormat;
}
 

import javax.media.protocol.ContentDescriptor; //导入依赖的package包/类
public FTPSourceStream(InputStream in)
{
   this.dataIn = in;
   eofMarker = false;
   cd = new ContentDescriptor("unknown");
}
 

import javax.media.protocol.ContentDescriptor; //导入依赖的package包/类
public ContentDescriptor getContentDescriptor()
{
   return cd;
}
 

import javax.media.protocol.ContentDescriptor; //导入依赖的package包/类
public ContentDescriptor getContentDescriptor() {
return actual.getContentDescriptor();
   }
 

import javax.media.protocol.ContentDescriptor; //导入依赖的package包/类
/***************************************************************************
    * SourceStream
    ***************************************************************************/
   
   public ContentDescriptor getContentDescriptor() {
return cd;
   }
 

import javax.media.protocol.ContentDescriptor; //导入依赖的package包/类
public ContentDescriptor getContentDescriptor() {
    return new ContentDescriptor(ContentDescriptor.RAW);
}
 

import javax.media.protocol.ContentDescriptor; //导入依赖的package包/类
public ContentDescriptor getContentDescriptor() {
    return null;
}
 

import javax.media.protocol.ContentDescriptor; //导入依赖的package包/类
public String getContentType() {
return ContentDescriptor.RAW;
   }
 

import javax.media.protocol.ContentDescriptor; //导入依赖的package包/类
/**
 * Returns RAW since buffers of video frames are sent without a container format.
 */
@Override
public String getContentType()
{
	return ContentDescriptor.RAW;
}
 

import javax.media.protocol.ContentDescriptor; //导入依赖的package包/类
public ContentDescriptor getContentDescriptor()
{
	return new ContentDescriptor(ContentDescriptor.RAW);
}
 

import javax.media.protocol.ContentDescriptor; //导入依赖的package包/类
public ContentDescriptor getContentDescriptor() {
   return new ContentDescriptor(ContentDescriptor.RAW);
}
 

import javax.media.protocol.ContentDescriptor; //导入依赖的package包/类
public String getContentType() {
   return ContentDescriptor.RAW;
}
 

import javax.media.protocol.ContentDescriptor; //导入依赖的package包/类
public void controllerUpdate(ControllerEvent p0) {
	if (p0 instanceof ConfigureCompleteEvent) {
		Format format;
		boolean encodingOK = false;

		TrackControl track[] = processor.getTrackControls();
		ContentDescriptor cd = new ContentDescriptor(
				ContentDescriptor.RAW_RTP);
		processor.setContentDescriptor(cd);
		format = track[prepare_track].getFormat();

		if (format instanceof VideoFormat) {
			VideoFormat v = (VideoFormat) track[prepare_track].getFormat();
			encodingOK = setMyVideoFormat(v, track[prepare_track]);
			if(HiloCliente.DEBUG){
				System.out.println("Pista "+prepare_track+" es de Video");
			}
		}
		if (format instanceof AudioFormat) {
			AudioFormat a = (AudioFormat) track[prepare_track].getFormat();
			encodingOK = setMyAudioFormat(a, track[prepare_track]);
			if(HiloCliente.DEBUG){
				System.out.println("Pista "+prepare_track+" es de Audio");
			}
		}

		if (encodingOK) {
			for (int i = 0; i < track.length; i++) {
				if (i != prepare_track) {
					track[i].setEnabled(false);
				}
			}
			processor.realize();
		}
	}

	if (p0 instanceof RealizeCompleteEvent) {
		try {
			ds = processor.getDataOutput();
			createMyRTPManager();
		} catch (NotRealizedError ex) {
			myEx(null, ex.getMessage());
		}
	}

	if (p0 instanceof EndOfMediaEvent) {
		closeMyStream();
		endofMedia = true;
	}
}
 

import javax.media.protocol.ContentDescriptor; //导入依赖的package包/类
/***************************************************************************
 * SourceStream
 ***************************************************************************/

public ContentDescriptor getContentDescriptor() {
	return cd;
}
 

import javax.media.protocol.ContentDescriptor; //导入依赖的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.protocol.ContentDescriptor; //导入依赖的package包/类
@Override
public ContentDescriptor getContentDescriptor() {
    return new ContentDescriptor(ContentDescriptor.RAW);
}