Pleaseeeeeeeeeee help

Question

AudioConf.java is the server code which sends the audio file which is saved in the disk.
Client.java is the receiver code which is supposed to receive which is not happening.
The client does not receive any stream but it can detect the new participant can u please give directions in what might be the problem.
//import java awt and net features
import java.awt.*;
import java.awt.event.*;
import java.util.Vector;
import java.net.*;
import java.lang.String;
import java.io.*;
// import javax media features
import javax.media.*;
import javax.media.Processor;
import javax.media.Multiplexer;
import javax.media.control.*;
import javax.media.control.TrackControl;
import javax.media.control.BufferControl;
import javax.media.format.*;
import javax.media.format.AudioFormat;
import javax.media.protocol.*;
import javax.media.protocol.DataSource;
import javax.media.protocol.PushDataSource;
//import javax rtp features
import javax.media.rtp.*;
import javax.media.rtp.SendStream;
import javax.media.rtp.event.RTPEvent;
import javax.media.rtp.rtcp.SourceDescription;
//import swing features
import javax.swing.*;
import javax.swing.event.*;
//import sun.com
import com.sun.media.*;
import com.sun.media.rtp.RTPSessionMgr;
public class AudioConf extends JFrame implements ControllerListener
Container frameContainer;
JMenuBar menuBar = new JMenuBar();
JMenu fileMenu = new JMenu("File");
JMenuItem fileExit = new JMenuItem("Exit");
JMenu playerMenu = new JMenu("Player");
JMenuItem playerCapture = new JMenuItem("Capture");
JMenuItem playerTransmit = new JMenuItem("Transmit");
JSeparator sep3 = new JSeparator();
JMenuItem playerPlay = new JMenuItem("Play");
JSeparator sep4 = new JSeparator();
JMenuItem playerStop = new JMenuItem("Stop");
JMenu helpMenu = new JMenu("Help");
JMenuItem helpAbout = new JMenuItem("About");
CaptureDeviceInfo audioCDI = null;
String audioDeviceName=null;
Player audioPlayer=null;
Format audioFormat;
DataSource dataSource;
MediaLocator ml;
Processor p = null;
DataSource ds = null;
CaptureDeviceInfo di=null;
Vector devicelist;
Thread recordthread;
boolean keepRun;
Button stopb;
boolean result;
DataSink filewriter = null;
MediaLocator dest;
Panel capturePanel;
boolean looping= true;
RTPManager rtpMgrs[];
int port = 3000;
DataSource dataOut = null;
Component visualComponent=null;
Component controllerComponent=null;
Player dualPlayer = null;
String contentType="raw";
boolean connected = false;
// MAIN FUNCTION
public static void main(String args[])
AudioConf conf = new AudioConf();
}//end of main
AudioConf()
buildGUI();
setupHandlers();
setSize(400,400);
setTitle("Audio Conference");
show();
}//end of audioconf constructor
//build the graphical user interface necessary
void buildGUI()
setupMenuBar();
layoutComp();
}//end of buildGUI
// setup the menu bar
void setupMenuBar()
     fileMenu.add(fileExit);
     playerMenu.add(playerCapture);
     playerMenu.add(playerTransmit);
     playerMenu.add(sep3);
     playerMenu.add(playerPlay);
     playerMenu.add(sep4);
     playerMenu.add(playerStop);
     helpMenu.add(helpAbout);
     menuBar.add(fileMenu);
     menuBar.add(playerMenu);
     menuBar.add(helpMenu);
     setJMenuBar(menuBar);
}//end of setupMenuBar
//setup the layout componenets
public void layoutComp()
     frameContainer = getContentPane();
frameContainer.setLayout(new BorderLayout());      
     }//end of layoutComp()
// setup the handlers to events
void setupHandlers()
     addWindowListener(new WindowHandler());
fileExit.addActionListener(new MenuItemHandler());
     playerCapture.addActionListener(new MenuItemHandler());
          playerTransmit.addActionListener(new MenuItemHandler());          
     playerPlay.addActionListener(new MenuItemHandler());
     playerStop.addActionListener(new MenuItemHandler());
     helpAbout.addActionListener(new MenuItemHandler());
     }//end of setupHandlers
// function for window closing event
public class WindowHandler extends WindowAdapter
public void windowClosing(WindowEvent e)
System.exit(0);
}//end of windowclosing
}//end of windowhandler
public class MenuItemHandler implements ActionListener
CaptureDeviceInfo audioCDI = null;
String audioDeviceName=null;
Player audioPlayer=null;
Format audioFormat;
DataSource dataSource;
public void actionPerformed(ActionEvent e)
String cmd = e.getActionCommand();
if(cmd.equals("Play"))
playMedia();
}//end of play
else if(cmd.equals("Capture"))
captureMedia();
else if(cmd.equals("Transmit"))
transmitMedia();
}//end of transmitMedia
else if(cmd.equals("Stop"))
stopmedia();
else if(cmd.equals("Exit"))
System.exit(0);
}//end of actionPerformed
}//end of MenuItemHandler
//*************************************Player******************************************************
void playMedia()
try
FileDialog fd=new FileDialog(AudioConf.this,"Select the file",FileDialog.LOAD);
fd.setVisible(true);
String filename = fd.getDirectory() + fd.getFile();
dualPlayer = Manager.createPlayer(new MediaLocator("file:///" + filename));
System.out.println("Adding controller listener");
dualPlayer.addControllerListener(this);
System.out.println("Starting player ...");
dualPlayer.start();
catch (Exception ex)
System.out.println(ex.toString());
}//end of playMedia
//************************************CONTROLLER UPDATE*************************************************
public synchronized void controllerUpdate(ControllerEvent ce)
     if (ce instanceof RealizeCompleteEvent)
          Component comp;
          System.out.println("Adding visual component");
          if ((comp = dualPlayer.getVisualComponent()) != null)
          frameContainer.add ("Center", comp);
          System.out.println("Adding control panel");
          if ((comp = dualPlayer.getControlPanelComponent()) != null)
          frameContainer.add("South", comp);
          validate();
     else if( ce instanceof DurationUpdateEvent)
     Time duration= ((DurationUpdateEvent) ce).getDuration();
     System.out.println( "duration: " + duration.getSeconds());
     else if( ce instanceof EndOfMediaEvent)
          System.out.println( "END OF MEDIA - looping=" + looping);
               if( looping)
                    p.setMediaTime( new Time( 0));
                         p.start();
//******************************Stop Playing**************************************************
public void stopmedia()
     if(dualPlayer!=null)
dualPlayer.close();
     dualPlayer.deallocate();
     validate();
//*************************************Capturing***************************************************
// Capture the media using datasource and save it using datasink
void captureMedia()
captureDialogBox captureDialog=new captureDialogBox(AudioConf.this,"CAPTURE MEDIA",false);
captureDialog.show();
class captureDialogBox extends Dialog implements ActionListener,Runnable
captureDialogBox(Frame parent, String title, boolean mode)
super(parent, title, mode);
setSize(450, 180);
setTitle("Capture");
capturePanel = new Panel();
capturePanel.setLayout(new BorderLayout());
     CaptureDeviceInfo di=null;
     Vector devicelist;
     keepRun = true;
          stopb = new Button("Stop");
capturePanel.add("South",stopb);
add(capturePanel,"Center");
          stopb.addActionListener(this);
devicelist = CaptureDeviceManager.getDeviceList(new AudioFormat("linear",44100,16,2));
if(devicelist.size() > 0)
di=(CaptureDeviceInfo)devicelist.firstElement();
else
System.exit(-1);
ml=di.getLocator();
System.out.println(ml);
     // Create a DataSource given the media locator.
try {
p = Manager.createProcessor(ml);
p.configure();
          result = waitForState(p,Processor.Configured);
System.out.println("Configure over ");
p.setContentDescriptor(new FileTypeDescriptor(FileTypeDescriptor.BASIC_AUDIO));
p.realize();
          result = waitForState(p,Processor.Realized);
System.out.println("Realized");
controllerComponent = p.getControlPanelComponent();
if(controllerComponent!=null)
capturePanel.add("North",controllerComponent);
visualComponent = p.getVisualComponent();
if(visualComponent!=null)
capturePanel.add("Center",visualComponent);
validate();
ds = p.getDataOutput();
catch (Exception e)
System.out.println("Cannot create DataSource from: " + ml + e.toString());
System.exit(0);
dest = new MediaLocator("file://c:\\jo\\Test.au");
try {
if(ds == null)
System.out.println("Source null ");
filewriter = Manager.createDataSink(ds, dest);
if (filewriter == null)
System.err.println("Failed to create a DataSink");
catch (NoDataSinkException e)
System.out.println("Error in store NoDataSinkException "+e.toString());
System.exit(-1);
catch (SecurityException e)
System.out.println("Error in store SecurityException "+e.toString());
System.exit(-1);
          try
filewriter.open();
p.start();
filewriter.start();
catch (IOException e)
System.out.println("Error Line abc in store IOException "+e.toString());
System.exit(-1);
recordthread = new Thread(this);
recordthread.start();
public void run()
while(keepRun)
System.out.println("Just record");
try{
recordthread.sleep(50);
}catch(Exception ex){
System.out.println("Line sss");
}//end of while
try{
filewriter.close();
}catch(Exception ex){
System.out.println("Error in closing ");
}//end of run
public void actionPerformed(ActionEvent ae)
keepRun = false;
//System.exit(0);
System.out.println("REcord Over");
recordthread.suspend();
dispose();
//*************************************************Transmission***************************************
void transmitMedia()
try {
MediaLocator playerloc = new MediaLocator("file://c:\\jo\\Test.au");
System.out.println(playerloc);
p = Manager.createProcessor(playerloc);
p.configure();
result = waitForState(p,Processor.Configured);
System.out.println("Configure over ");
          ContentDescriptor cd = new ContentDescriptor(ContentDescriptor.RAW_RTP);
          p.setContentDescriptor(cd);
TrackControl track[]=p.getTrackControls();
boolean encodingPossible = false;
for(int i = 0;i<track.length;i++)
if(!encodingPossible && track[i] instanceof FormatControl)
try
((FormatControl)track).setFormat(new AudioFormat(AudioFormat.ULAW_RTP,8000,8,1));
encodingPossible = true;
}//end of try
catch(Exception e)
          System.out.println("IncompatibleFormatException ");
}//end of if
          else
               System.out.println("else part");
track[i].setEnabled(false);
               }//end of else
}//end of for
p.realize();
          boolean result=waitForState(p,Processor.Realized);
System.out.println("Realized");
System.out.println("Datasource created successfully");
     catch(Exception ex)
     System.out.println("EXception in creating processor");
try
dataOut=p.getDataOutput();
System.out.println(dataOut.toString());
catch(NotRealizedError e)
System.out.println("NotRealizedError");
if(dataOut==null)
System.out.println("Dataout is null");
PushBufferDataSource pbds = (PushBufferDataSource)dataOut;
System.out.println("pbds =" + pbds.toString());
     PushBufferStream pbss[] = pbds.getStreams();
System.out.println("pbss length = " + pbss.length);
     rtpMgrs = new RTPManager[pbss.length];
     SessionAddress localAddr, destAddr;
     InetAddress ipAddr;
     SendStream sendStream;
     SourceDescription srcDesList[];
     for (int i = 0; i < pbss.length; i++)
     try
          rtpMgrs[i] = RTPManager.newInstance();     
System.out.println("rtpMgrs created using new instance");
     System.out.println("port = " + port);
ipAddr = InetAddress.getLocalHost();     
          InetAddress hostAddr= InetAddress.getLocalHost();
System.out.println("Local host= " + hostAddr);
          localAddr = new SessionAddress( hostAddr,3000);
System.out.println("localAddr = " + localAddr);
destAddr = new SessionAddress( ipAddr, 4000);
System.out.println("destAddr = " + destAddr);
rtpMgrs[i].initialize(localAddr);
          rtpMgrs[i].addTarget(destAddr);
          System.out.println( "Created RTP session: ");
          sendStream = rtpMgrs[i].createSendStream(dataOut, i);          
System.out.println("stream send created");
sendStream.start();
System.out.println("sendstream started");
     catch (Exception e)
          System.out.println("Error"+e.toString());
          e.printStackTrace();
}//end of for
}//end of transmitMedia
// ***********************************STATE LOCK**********************************************
private Integer stateLock = new Integer(0);
private boolean failed = false;
Integer getStateLock() {
     return stateLock;
void setFailed() {
     failed = true;
// *******************************************WAIT FOR STATE METHOD *********************
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;
// ********************************* STATE LISTENER *************************************
class StateListener implements ControllerListener
     public void controllerUpdate(ControllerEvent ce)
     // If there was an error during configure or
     // realize, the processor will be closed
     if (ce instanceof ControllerClosedEvent)
          setFailed();
     // All controller events, send a notification
     // to the waiting thread in waitForState method.
     if (ce instanceof ControllerEvent)
          synchronized (getStateLock())
          getStateLock().notifyAll();
}//end of audioconf class
Client program - this program receives the stream and play it
//import awt and net features
import java.awt.*;
import java.awt.event.*;
import java.util.Vector;
import java.net.*;
import java.lang.String;
import java.io.*;
// import the media features
import javax.media.*;
import javax.media.MediaEvent;
import javax.media.Processor;
import javax.media.Multiplexer;
import javax.media.control.*;
import javax.media.control.TrackControl;
import javax.media.control.BufferControl;
import javax.media.format.*;
import javax.media.format.AudioFormat;
import javax.media.protocol.*;
import javax.media.protocol.DataSource;
import javax.media.rtp.*;
import javax.media.rtp.event.*;
import javax.media.rtp.rtcp.*;
import javax.media.rtp.event.RTPEvent;
import javax.media.rtp.RTPManager;
import javax.media.rtp.ReceiveStreamListener;
import javax.media.rtp.rtcp.SourceDescription;
// import the swing features
import javax.swing.*;
import javax.swing.event.*;
// for sessionmedia
import com.sun.media.*;
import com.sun.media.rtp.RTPSessionMgr;
// for PlayerWindow
import com.sun.media.ui.*;
public class client extends JFrame implements ReceiveStreamListener,ControllerListener,SessionListener
Vector playerlist = new Vector();
RTPManager mgr = null;
boolean terminatedbyClose = false;
String address="127.0.0.1";
int port=4000;
int ttl=100;
DataSink filewriter = null;
DataSource dsource=null;
Container frameContainer;
MediaLocator f=null;
JMenuBar menuBar = new JMenuBar();
JMenu fileMenu = new JMenu("File");
JMenuItem fileExit = new JMenuItem("Exit");
JMenu playerMenu = new JMenu("Player");
JMenuItem playerReceive = new JMenuItem("Receive");
JMenuItem playerIgnore = new JMenuItem("Stop");
client()
buildGUI();
setupHandlers();
setSize(400,400);
setTitle("Audio Conference");
show();
}//end of audioconf constructor
//build the graphical user interface necessary
void buildGUI()
setupMenuBar();
layoutComp();
}//end of buildGUI
// setup the menu bar
void setupMenuBar()
     fileMenu.add(fileNew);
     fileMenu.add(sep1);
     fileMenu.add(fileClose);
     fileMenu.add(sep2);
     fileMenu.add(fileExit);
     playerMenu.add(playerReceive);
     playerMenu.add(playerIgnore);
     menuBar.add(fileMenu);
     menuBar.add(playerMenu);
setJMenuBar(menuBar);
}//end of setupMenuBar
//setup the layout componenets
public void layoutComp()
     frameContainer = getContentPane();
frameContainer.setLayout(new BorderLayout());      
     }//end of layoutComp()
// setup the handlers to events
void setupHandlers()
     addWindowListener(new WindowHandler());
     fileNew.addActionListener(new MenuItemHandler());
fileClose.addActionListener(new MenuItemHandler());
fileExit.addActionListener(new MenuItemHandler());
     playerReceive.addActionListener(new MenuItemHandler());
          playerIgnore.addActionListener(new MenuItemHandler());          
     }//end of setupHandlers
// function for window closing event
public class WindowHandler extends WindowAdapter
public void windowClosing(WindowEvent e)
System.exit(0);
}//end of windowclosing
}//end of windowhandler
// menuItem handler class to get action from menu items
public class MenuItemHandler implements ActionListener
     public void actionPerformed(ActionEvent e)
String cmd = e.getActionCommand();
if(cmd.equals("Exit"))
System.exit(0);
else if(cmd.equals("Receive"))
          receiveData();
}//end of play
else if(cmd.equals("Ignore"))
ignoreData();
}//end of actionPerformed
}//end of menuitemhandler
/* *******************************IGNORE STREAM**************** */
void ignoreData()
IgnoreDialog igDialog=new IgnoreDialog(client.this,"IGNORE THE STREAM",false);
igDialog.show();
}//end of ignoreData
class IgnoreDialog extends Dialog implements ActionListener
     // constructor
IgnoreDialog(Frame parent, String title, boolean mode)
super(parent, title, mode);
setSize(250, 120);
Panel p = new Panel();
p.setLayout(null);
Label display = new Label("The Stream sent has been ignored");
Button OKbutton = new Button("OK");
          p.add(display);
display.setBounds(5, 5, 200, 20);
          p.add(OKbutton);
OKbutton.setBounds(80, 50, 60, 25);
          add(p, "Center");
          OKbutton.addActionListener(this);
          }//end of constructor
//actionPerformed in the dialog box
     public void actionPerformed(ActionEvent ae)
dispose();
}//end of actionperformed
}//end of IgnoreDialog class
/* *******************************RECEIVE STREAM**************** */
// receive the data
void receiveData()
SessionAddress localaddr = null;
SessionAddress remoteaddr = null;
InetAddress destaddr = null;
mgr = RTPManager.newInstance();
System.out.println("mgr is created");
     if (mgr == null)
          System.out.println("Manager is null");
     mgr.addFormat(new AudioFormat(AudioFormat.DVI_RTP,44100,4,1),18);
     // Register RecvStreamListener with the session manager
try
destaddr = InetAddress.getLocalHost();
     localaddr = new SessionAddress(destaddr,4000);
remoteaddr = new SessionAddress(destaddr,3000);
     System.out.println("local addr : " + localaddr);
     System.out.println("remote addr : " + remoteaddr);
     mgr.initialize(localaddr);
     mgr.addTarget(remoteaddr);
mgr.addSessionListener(this);
     mgr.addReceiveStreamListener(this);
System.out.println("mgr initialised");
BufferControl bc = (BufferControl)mgr.getControl("javax.media.control.BufferControl");
          if (bc != null)
          bc.setBufferLength(350);
catch(Exception e)
     System.out.println("initialized error" + e.toString());
}//end of receiveData
* SessionListener.
public synchronized void update(SessionEvent evt)
     if (evt instanceof NewParticipantEvent)
     Participant p = ((NewParticipantEvent)evt).getParticipant();
     System.err.println(" - A new participant had just joined: " + p.getCNAME());
public synchronized void update(ReceiveStreamEvent event)
          Player newplayer = null;
          RTPPlayerWindow playerWindow = null;
     Vector streams = null;
ReceiveStream stream = null;
     // find the sourceRTPSM for this event
try
Participant part1 = event.getParticipant();
          streams = part1.getStreams();
          System.out.println("Streams Length "+streams.size());
          RTPManager source =(RTPManager) event.getSource();
          System.out.println(" source " + source);
          System.out.println("inside source try");
          stream = event.getReceiveStream();
          System.out.println("STream received : =" + stream.toString());
     catch(Exception e)
          System.out.println("Source not obtained" + e.toString());
System.out.println("outside try-catch");
     // create a new player if a new recvstream is detected
try
                    System.out.println("entered try ");
dsource = stream.getDataSource();
                    System.out.println("Dsource is obtained " + dsource);
                    f = new MediaLocator("file://c:\\jo1\foo.au");
                    catch(Exception e)
                         System.out.println("Dsource exception = "+ e.toString());
                    try
                    filewriter = Manager.createDataSink(dsource, f);
System.out.println("Datasink created");
                    catch(Exception e)
                         System.out.println("Datasink exception = "+ e.toString());
     if (event instanceof NewReceiveStreamEvent)
          String cname = "Java Media Player";
          //ReceiveStream stream = null;
               try
               // get a handle over the RTPRecvStream
                    stream = ((NewReceiveStreamEvent)event).getReceiveStream();
                    System.out.println("straem : " +stream);
                    Participant part = stream.getParticipant();
                    System.out.println("partcipant : " + part);
                    if (part != null)
                         cname = part.getCNAME();
                         System.out.println("Cname = " + cname);
               // get a handle over the RecvStream datasource
/*                    DataSource dsource = stream.getDataSource();
                    MediaLocator f = new MediaLocator("file://c:\foo.au");
                    Manager.createDataSink(dsource, f);
System.out.println("Datasink created");
               // create a player by passing datasource to the Media Manager
                    newplayer = Manager.createPlayer(dsource);
                    System.out.println("created player " + newplayer);
               catch (Exception e)
                    System.out.println("newRecvStreamEvent exception " +e.getMessage());
          if (newplayer == null)
               System.out.println("new player is null");
          playerlist.addElement(newplayer);
          newplayer.addControllerListener(this);
          // send this player to player GUI
          playerWindow = new RTPPlayerWindow( newplayer, cname );
          }// instanceof newRecvStreamEvent
     }// end of update(RTPRecvStreamEvent)
public void controllerUpdate(ControllerEvent evt)
          // get a handle over controller, remove it from the player list
          // if player list is empty, close the sesssion manager.
          if ((evt instanceof ControllerClosedEvent) ||(evt instanceof ControllerErrorEvent) ||(evt instanceof DeallocateEvent))
               Player p = (Player)evt.getSourceController();
                    if (!terminatedbyClose)
                         if (playerlist.contains(p))
                              playerlist.removeElement(p);
                         if ((playerlist.size() == 0) && (mgr != null))
                              mgr.dispose();
                         }//edn of if
               }//end of if
     }//end of controllerupdate
     public void closeManager()
          terminatedbyClose = true;
          // first close all the players
          for (int i = 0; i < playerlist.size(); i++)
               ((Player)playerlist.elementAt(i)).close();
          if (mgr != null)
               mgr.dispose();     
               mgr = null;
     }//end of closeManager
     class RTPPlayerWindow extends PlayerWindow
               public RTPPlayerWindow(Player player, String title)
                    super(player);
                    setTitle(title);
               public void Name(String title)
                    setTitle(title);
          }// end of PlayerWindow
public static void main(String args[])
client cl=new client();
}//END OF MAIN
}//end of client

Answer 1

hi there
as far as i can see, you don't start the processor
that provides the datasource to the manager, before
starting the sendstream.
rtpMgrs.initialize(localAddr);
rtpMgrs.addTarget(destAddr);
System.out.println( "Created RTP session: ");
sendStream = rtpMgrs.createSendStream(dataOut, i);
System.out.println("stream send created");p.start();
sendStream.start();
System.out.println("sendstream started")