Problem with clone DataSource
I have a program that transmit video from webcam to various clients , but it also must save a video if the client want. My problem is that i must create a clone from the datasource that is sent to save the video but when i close i stopped saving and i want to save a nother video i can't use the same clonedatasource why?This program it's always running i can磘 stop it and restart it because if i can do that it was more simply i need that it's always running and saving every time i want.Here his the code from the two classes:
package projecto;
import java.io.*;
import java.net.*;
import java.util.Vector;
import javax.media.*;
import javax.media.protocol.*;
import javax.media.rtp.*;
import javax.media.control.*;
import javax.media.format.*;
publicclass RTP_Server{
//file or medialocator,port number
privateint []port=newint[4];
//private MediaLocator []mediaLocator=new MediaLocator[4];
private DataSource []mediaLocator=new DataSource [4];
//processor controlling dataflow
private Processor []processor=new Processor[4];
//data output from processor to be sent
private DataSource outsource;
//media track's configurable controls
private TrackControl tracks[];
//suported RTP formats of a track
Format rtpFormats[];
// Contains the device properties
private CaptureDeviceInfo device;
private Vector deviceList;
privateint media_Enviar=0;
privateboolean []transmitir=newboolean[]{false,false,false,false};
privateboolean []processoIniciado=newboolean[]{false,false,false,false};
/******************************/
privateint qualClone=0;
private DataSource []original=new DataSource[4];
private DataSource []ClonesourceUm=new DataSource[4];
private DataSource []ClonesourceDois=new DataSource[4];
private GravarFicheiro gf;
DataSource source;
private FormatControl formatControl[];
private Format formats[],selectedFormat;
/******************************/
/**********RTP***********/
//Um rtp manager por track
private RTPManager rtpManager[]=new RTPManager[4];
// destination and local RTP session addresses
SessionAddress localAddress;
//SessionAddress remoteAddress;
//RTP stream being sent
SendStream sendStream;
//Ip address
InetAddress ip;
/************************/
//construtor
public RTP_Server(int []portNumber){
mediaLocator=escolherDispositivo();
for(int i=0;i<2;i++){
original[i]=Manager.createCloneableDataSource(mediaLocator[i]);
//nao da para gravar varias vezes
ClonesourceUm[i]=((SourceCloneable)original[i]).createClone();
ClonesourceDois[i]=((SourceCloneable)original[i]).createClone();
//fecha a datasource
//ClonesourceUm[i]=Manager.createCloneableDataSource(mediaLocator[i]);
}
mediaLocator[0].disconnect();
mediaLocator[1].disconnect();
port=portNumber;
}
//initialize and set up processor return true if successful,false if not
publicsynchronizedboolean beginSession(InetAddress ipCliente,SessionAddress remoteAddress){
ip=ipCliente;
try{
mediaLocator[media_Enviar].connect();
}catch (IOException e1){
e1.printStackTrace();
}
transmitir[media_Enviar]=true;
if(mediaLocator[media_Enviar]==null){
System.err.println("Nenhum DataSource!!!");
returnfalse;
}
//create processor from MediaLocator
try{
processoIniciado[media_Enviar]=true;
//processor[media_Enviar]=Manager.createProcessor(original);mediaLocator[media_Enviar]
processor[media_Enviar]=Manager.createProcessor(original[media_Enviar]);
//register a ControllerListener for processo to listen for state and transition events
processor[media_Enviar].addControllerListener(new ProcessorEventHandler());
//configure processor before setting up
processor[media_Enviar].configure();//Prepares the Processor to be programmed
while(processor[media_Enviar].getState()!=processor[media_Enviar].Configured){
try{
Thread.sleep(500);
}catch (InterruptedException e){
e.printStackTrace();
}
}
setOutputFormat();
System.out.println("Processor Configured...");
processor[media_Enviar].realize();
while(processor[media_Enviar].getState()!=processor[media_Enviar].Realized){
try{
Thread.sleep(500);
}catch (InterruptedException e){
e.printStackTrace();
}
}
//start sending when processor is realized
if(transmitMedia(remoteAddress)==true){
System.out.println("\nTransmission setup OK");
}
else{
System.out.println("\nTransmission Failed");
}
}
//exception thrown when no processor could be found for specific data source
catch (NoProcessorException e){
e.printStackTrace();
returnfalse;
}
//source connection error
catch (IOException e){
e.printStackTrace();
returnfalse;
}
returntrue;
}
privateclass ProcessorEventHandlerextends ControllerAdapter{
}
// set output format for all tracks in media
publicvoid setOutputFormat(){
//set output content type to RTP capable format
processor[media_Enviar].setContentDescriptor(new ContentDescriptor(ContentDescriptor.RAW_RTP));
//get all track controls of processor
tracks=processor[media_Enviar].getTrackControls();
//set each track to first supported RTP format found in each track
for(int i=0;i<tracks.length;i++){
System.out.println("\nTrack #" + (i+1) +"supports ");
if(tracks[i].isEnabled()){//Checks whether or not this Track is enabled.
rtpFormats=tracks[i].getSupportedFormats();
//if supported formats of track exist,display all suported RTP formats
// and set track format to be first supported format
if(rtpFormats.length>0){
for(int j=0;j<rtpFormats.length;j++)System.out.println(rtpFormats[j]);
tracks[i].setFormat(rtpFormats[0]);
System.out.println("Track format set to " + tracks[i].getFormat());
}
else System.err.println("No supported RTP formats for track!");
}
}
}
/*****************Transmitir inform鏰o e adicionar novos destinos***************************/
publicsynchronizedboolean transmitMedia(SessionAddress remoteAddress){
/* Gets the output DataSource from the Processor*/
outsource=processor[media_Enviar].getDataOutput();
if(outsource ==null){
System.out.println("No data source from media");
returnfalse;
}
//initialize transmission address and send out media
try{
//instantiate a RTPManager
rtpManager[media_Enviar]=RTPManager.newInstance();
//encapsulate pair of IP addresses for control and data
//with 2 ports into local session address
localAddress=new SessionAddress(ip.getLocalHost(),port[media_Enviar]);
//get remoteAddress session address
//remoteAddress=new SessionAddress(ip,port[media_Enviar]);
//initialize session
rtpManager[media_Enviar].initialize(localAddress);
//open RTP session for destination
rtpManager[media_Enviar].addTarget(remoteAddress);
System.out.println("\nStarted RTP session: "+ ip +" " + port[media_Enviar]);
//create send stream in RTP session
sendStream=rtpManager[media_Enviar].createSendStream( outsource, 0);
//start sending the stream
sendStream.start();
System.out.println("Transmitting Track # "+(media_Enviar+1)+" ...");
//start media feed
processor[media_Enviar].start();
//System.out.println(remoteAddress.getControlAddress());
}
//unknow local or unresolvable remote address
catch(InvalidSessionAddressException addressError){
addressError.printStackTrace();
returnfalse;
}
//Datasource connection error
catch(IOException ioException){
ioException.printStackTrace();
}
//format not set or invalid format set on stream source
catch(UnsupportedFormatException formatException){
formatException.printStackTrace();
returnfalse;
}
//transmission initialized successfully
returntrue;
}
publicsynchronizedvoid adicionarDestino(InetAddress ipC,int camera,SessionAddress remoteAddress){
try{
if(transmitir[camera]==false){
System.out.println("reiniciar processo");
transmitir[camera]=true;
processor[ camera].start();
}
//camera 0,1,2,3 rtpManager 0,1,2,3
rtpManager[camera].addTarget(remoteAddress);
}
catch (InvalidSessionAddressException e){
e.printStackTrace();
}
catch (IOException e){
e.printStackTrace();
}
}
/***********Fim do Transmitir inform鏰o e adicionar novos destinos***************************/
/*******************parar a transmissao e fechar recursos***********************************/
publicsynchronizedvoid stopTransmission(int camera){
if(processor[ camera]!=null){
//stop processor
processor[ camera].stop();
/*******************************/
/*
try {
original[camera].stop();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
*/
/*******************************/
//dispose processor
/*processor[ camera].close();
if(rtpManager[camera] != null)
//close destination targets and dispose RTP managers
//close streams to all destinations with a reason for termination
rtpManager[ camera].removeTargets( "Session Stopped");
//release RTP session resources
rtpManager[ camera].dispose();
*/
}
transmitir[camera]=false;
System.out.println("Transmission Stopped da Camera" + (camera+1));
}
publicsynchronizedvoid pararTransmissao(SessionAddress sessaoRemover,int camera){
//camera 0,1,2,3 rtpManager 0,1,2,3
try{
rtpManager[ camera].removeTarget(sessaoRemover,"Sessao desligada");
}
catch (InvalidSessionAddressException e){
e.printStackTrace();
}
}
/*******Fim do parar a transmissao e fechar recursos***********************************/
/**********************************Obter Informa鏾es****************************************************/
publicboolean getTransmitir(int n){
return transmitir[n];
}
publicint getMediaEnviar(){
return media_Enviar;
}
publicvoid setMediaEnviar(int numero){
media_Enviar=numero;
}
publicboolean getProcesso(int processo){
return processoIniciado[processo];
}
/**********************Fim do Obter Informa鏾e**************************************************************/
/**************************************Gravar************************************************/
publicsynchronizedvoid gravarVideo(int camera){
//public synchronized void gravarVideo(GravarFicheiro gf,int camera){
if(camera==1){
try{
if(transmitir[media_Enviar]==false){
mediaLocator[media_Enviar].connect();
}
}
catch (IOException e){
e.printStackTrace();
}
/*
* Como o datasource enviado ?um clone do original este precisa do primeiro a correr
* para dp parar senao da null exception se utlizassemos o original ja nao dava problema
*/
if(qualClone==0){
gf=new GravarFicheiro(ClonesourceUm[media_Enviar],selectedFormat);
++qualClone;
}
else{
gf=new GravarFicheiro(ClonesourceDois[media_Enviar],selectedFormat);
}
//gf.Gravar(ClonesourceUm[media_Enviar],selectedFormat);
}
}
publicsynchronizedvoid pararVideo(int camera){
if(camera==1){
gf.stop();
}
}
/*******************************Fim do Gravar************************************************/
//array de cameras so q agora ta tudo na 1?posi鏰o para nao iniciar a camera
public DataSource[] escolherDispositivo(){
DataSource []aux=new DataSource[4];
deviceList = CaptureDeviceManager.getDeviceList(new VideoFormat(VideoFormat.RGB) );
//System.out.println(deviceList);
device = (CaptureDeviceInfo) deviceList.firstElement();
//System.out.println( device.getFormats());
try{
aux[0]=Manager.createDataSource(device.getLocator());
}catch (NoDataSourceException e1){
e1.printStackTrace();
}catch (IOException e1){
e1.printStackTrace();
}
/**********para posssibilitar a grava鏰o*********************/
formatControl =((CaptureDevice)aux[0]).getFormatControls();
formats=device.getFormats();
//selectedFormat=formats[3];
selectedFormat=formats[0];
System.out.println(selectedFormat);
if(formatControl[0].isEnabled()){
System.out.println("certo");
}
formatControl[0].setFormat(selectedFormat);
/*********************************************************/
File f=new File("teste_camera2.avi");
try{
aux[1] =Manager.createDataSource(f.toURL());;
}
catch (MalformedURLException e){
e.printStackTrace();
}
catch (NoDataSourceException e){
e.printStackTrace();
}catch (IOException e){
e.printStackTrace();
}
return aux;
}
/*******************************************************************************************************/
publicstaticvoid main (String[]args){
int []portas=newint[]{30000,40000};
RTP_Server rserver=new RTP_Server(portas);
rserver.media_Enviar=1;
InetAddress ip;
try{
ip = InetAddress.getLocalHost();
//rserver.beginSession(ip);
}catch (UnknownHostException e1){
// TODO Auto-generated catch block
e1.printStackTrace();
}
try{
Thread.sleep(30000);
}catch (InterruptedException e){
e.printStackTrace();
}
rserver.stopTransmission(0);
/*rserver.media_Enviar=1;
rserver.beginSession();*/
}
}
Saving Video:
package projecto;
import java.io.*;
import java.net.MalformedURLException;
import java.net.UnknownHostException;
import java.util.*;
import javax.media.*;
import javax.media.control.FormatControl;
import javax.media.datasink.DataSinkEvent;
import javax.media.datasink.DataSinkListener;
import javax.media.datasink.EndOfStreamEvent;
import javax.media.format.*;
import javax.media.protocol.*;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
publicclass GravarFicheiro{
private DataSource insource,outSource;
private Format selectedFormat;
private Processor processor;
private MediaLocator salvar;
private DataSink gravar;
privateint n_utilz_Cameras[]={0};
public GravarFicheiro(){
}
public GravarFicheiro(DataSource aux,Format sf ){
insource=aux;
//formato q recebe o video
selectedFormat=sf;
capturar();
}
publicvoid Gravar(DataSource aux,Format sf ){
insource=aux;
//formato q recebe o video
selectedFormat=sf;
capturar();
}
publicvoid capturar(){
Format outFormato[]=new Format[1];
outFormato[0]=selectedFormat;
//formato em que grava o video
FileTypeDescriptor outFile=new FileTypeDescriptor(FileTypeDescriptor.QUICKTIME);
try{
processor = Manager.createRealizedProcessor(new ProcessorModel(insource,outFormato,outFile));
}
catch (NoProcessorException e){
e.printStackTrace();
}
catch (CannotRealizeException e){
e.printStackTrace();
}
catch (IOException e){
e.printStackTrace();
}
/*********************************************/
File ficheiro = getSaveFile();
if(ficheiro==null)System.out.println("Formato invalido");
outSource=processor.getDataOutput();
if(outSource==null){
System.out.println("Sem output");
}
try{
salvar=new MediaLocator(ficheiro.toURL());
}
catch (MalformedURLException e){
e.printStackTrace();
}
try{
gravar=Manager.createDataSink(outSource, salvar);
gravar.addDataSinkListener(
new DataSinkListener(){
publicvoid dataSinkUpdate(DataSinkEvent dataEvent){
if(dataEventinstanceof EndOfStreamEvent)
gravar.close();
}
}
);
}
catch (NoDataSinkException e){
e.printStackTrace();
}
try{
gravar.open();
gravar.start();
}
catch (SecurityException e){
e.printStackTrace();
}
catch (IOException e){
e.printStackTrace();
}
/********************************************/
processor.start();
}
public File getSaveFile(){
File f=new File("camera1"+this.nomeFicheiro()+".mov");
return f;
}
publicvoid stop(){
System.out.println("Parar Gravagem");
processor.stop();
//ao por close ele acaba a grava鏰o mas nao deixa fazer uma nova
processor.close();
gravar.close();
}
public String nomeFicheiro(){
Calendar c = Calendar.getInstance();
return"_"+c.get(Calendar.DAY_OF_MONTH)+"-"+c.get(Calendar.MONTH)+"_"+c.get(Calendar.HOUR_OF_DAY)+"h"+c.get(Calendar.MINUTE)+"m";
}
publicstaticvoid main(String [] args){
GravarFicheiro g=new GravarFicheiro();
System.out.println(g.nomeFicheiro());
}
}
if anyone can help me please.
Thanks>
