Problem with using JMF audio over a network

Question

Hiya, I'm using IBM JMF code but I'm having problems trying to get it transmit data from the MediaTransmitter to the MediaPlayerFrame.
I'm kinda new to JMF so I assume I'm missing something basis for why this doesn't work.
Any help would be greatly appreciated.
MediaPlayerFrame
import javax.media.*;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.io.*;
* An instance of the MediaPlayerFrame may be used to display any media
* recognized * by JMF.  This is intended to be a very simple GUI example,
* displaying all possible controls for the given media type.
public class MediaPlayerFrame extends JFrame {
     * The frame title.
    private static final String FRAME_TITLE = "developerWorks JMF Tutorial " +
        "Media Player";
     * The panel title of the main control panel.
    private static final String CONTROL_PANEL_TITLE = "Control Panel";
    // location and size variables for the frame.
    private static final int LOC_X = 100;
    private static final int LOC_Y = 100;
    private static final int HEIGHT = 500;
    private static final int WIDTH = 500;
     private final static long serialVersionUID = 1;
     * The current player.
    private Player player = null;
     * The tabbed pane for displaying controls.
    private JTabbedPane tabPane = null;
     * Create an instance of the media frame.  No data will be displayed in the
     * frame until a player is set.
    public MediaPlayerFrame() {         
        super(FRAME_TITLE);
        System.out.println("MediaPlayerFrame");
        setLocation(LOC_X, LOC_Y);
        setSize(WIDTH, HEIGHT);
        tabPane = new JTabbedPane();
        getContentPane().add(tabPane);
        /* adds a window listener so that the player may be cleaned up before
           the frame actually closes.
        addWindowListener(new WindowAdapter() {
                               * Invoked when the frame is being closed.
                              public void windowClosing(WindowEvent e) {
                                  closeCurrentPlayer(); 
                                  /* Closing this frame will cause the entire
                                     application to exit.  When running this
                                     example as its own application, this is
                                     fine - but in general, a closing frame
                                     would not close the entire application. 
                                     If this behavior is not desired, comment
                                     out the following line:
                                  System.exit(0);
     * Creates the main panel.  This panel will contain the following if they
     * exist:
     * - The visual component: where any visual data is displayed, i.e. a
     * movie uses this control to display the video.
     * - The gain component:   where the gain/volume may be changed.  This
     * is often * contained in the control panel component (below.)
     * - The control panel component: time and some extra info regarding
     * the media.
    private JPanel createMainPanel() {
        System.out.println("createMainPanel");
        JPanel mainPanel = new JPanel();
        GridBagLayout gbl = new GridBagLayout();
        GridBagConstraints gbc = new GridBagConstraints();
        mainPanel.setLayout(gbl);
        boolean visualComponentExists = false;
        // if the visual component exists, add it to the newly created panel.
        if (player.getVisualComponent() != null) {
            visualComponentExists = true;
            gbc.gridx = 0;
            gbc.gridy = 0;
            gbc.weightx = 1;
            gbc.weighty = 1;
            gbc.fill = GridBagConstraints.BOTH;
            mainPanel.add(player.getVisualComponent(), gbc);
        // if the gain control component exists, add it to the new panel.
        if ((player.getGainControl() != null) &&
            (player.getGainControl().getControlComponent() != null)) {
            gbc.gridx = 1;
            gbc.gridy = 0;
            gbc.weightx = 0;
            gbc.weighty = 1;
            gbc.gridheight = 2;
            gbc.fill = GridBagConstraints.VERTICAL;
            mainPanel.add(player.getGainControl().getControlComponent(), gbc);
        // Add the control panel component if it exists (it should exists in
        // all cases.)
        if (player.getControlPanelComponent() != null) {
            gbc.gridx = 0;
            gbc.gridy = 1;
            gbc.weightx = 1;
            gbc.gridheight = 1;
            if (visualComponentExists) {
                gbc.fill = GridBagConstraints.HORIZONTAL;
                gbc.weighty = 0;
            } else {
                gbc.fill = GridBagConstraints.BOTH;
                gbc.weighty = 1;
            mainPanel.add(player.getControlPanelComponent(), gbc);
        return mainPanel;
     * Sets the media locator.  Setting this to a new value effectively
     * discards any Player which may have already existed.
     * @param locator the new MediaLocator object.
     * @throws IOException indicates an IO error in opening the media.
     * @throws NoPlayerException indicates no player was found for the
     * media type.
     * @throws CannotRealizeException indicates an error in realizing the
     * media file or stream.
    public void setMediaLocator(MediaLocator locator) throws IOException,
        NoPlayerException, CannotRealizeException {
          System.out.println("setMediaLocator: " +locator);
        // create a new player with the new locator.  This will effectively
        // stop and discard any current player.
        setPlayer(Manager.createRealizedPlayer(locator));       
     * Sets the player reference.  Setting this to a new value will discard
     * any Player which already exists.  It will also refresh the contents
     * of the pane with the components for the new player.  A null value will
     * stop the discard the current player and clear the contents of the
     * frame.
    public void setPlayer(Player newPlayer) {      
        System.out.println("setPlayer");
        // close the current player
        closeCurrentPlayer();          
        player = newPlayer;
        // refresh the tabbed pane.
        tabPane.removeAll();
        if (player == null) return;
        // add the new main panel
        tabPane.add(CONTROL_PANEL_TITLE, createMainPanel());
        // add any other controls which may exist in the player.  These
        // controls should already contain a name which is used in the
        // tabbed pane.
        Control[] controls = player.getControls();
        for (int i = 0; i < controls.length; i++) {
            if (controls.getControlComponent() != null) {
tabPane.add(controls[i].getControlComponent());
* Stops and closes the current player if one exists.
private void closeCurrentPlayer() {
if (player != null) {
player.stop();
player.close();
* Prints a usage message to System.out for how to use this class
* through the command line.
public static void printUsage() {
System.out.println("Usage: java MediaPlayerFrame mediaLocator");
* Allows the user to run the class through the command line.
* Only one argument is allowed, which is the media locator.
public static void main(String[] args) {
try {
if (args.length == 1) {
MediaPlayerFrame mpf = new MediaPlayerFrame();
/* The following line creates a media locator using the String
passed in through the command line. This version should
be used when receiving media streamed over a network.
mpf.setMediaLocator(new MediaLocator(args[0]));
/* the following line may be used to create and set the media
locator from a simple file name. This works fine when
playing local media. To play media streamed over a
network, you should use the previous setMediaLocator()
line and comment this one out.
//mpf.setMediaLocator(new MediaLocator(
// new File(args[0]).toURL()));
mpf.setVisible(true);
} else {
printUsage();
} catch (Throwable t) {
t.printStackTrace();
MediaTransmitter
import javax.media.*;
import javax.media.control.*;
import javax.media.protocol.*;
import javax.media.format.*;
import java.io.IOException;
import java.io.File;
* Creates a new media transmitter.  The media transmitter may be used to
* transmit a data source over a network.
public class MediaTransmitter {
     * Output locator - this is the broadcast address for the media.
    private MediaLocator mediaLocator = null;
     * The data sink object used to broadcast the results from the processor
     * to the network.
    private DataSink dataSink = null;
     * The processor used to read the media from a local file, and produce an
     * output stream which will be handed to the data sink object for
     * broadcast.
    private Processor mediaProcessor = null;
     * The track formats used for all data sources in this transmitter.  It is
     * assumed that this transmitter will always be associated with the same
     * RTP stream format, so this is made static.
    private static final Format[] FORMATS = new Format[] {
        new AudioFormat(AudioFormat.MPEG_RTP)};
     * The content descriptor for this transmitter.  It is assumed that this
     * transmitter always handles the same type of RTP content, so this is
     * made static.
    private static final ContentDescriptor CONTENT_DESCRIPTOR =
        new ContentDescriptor(ContentDescriptor.RAW_RTP);
     * Creates a new transmitter with the given outbound locator.
    public MediaTransmitter(MediaLocator locator) {
        mediaLocator = locator;
     * Starts transmitting the media.
    public void startTransmitting() throws IOException {
        // start the processor
        mediaProcessor.start();
        // open and start the data sink
        dataSink.open();
        dataSink.start();
     * Stops transmitting the media.
    public void stopTransmitting() throws IOException {
        // stop and close the data sink
        dataSink.stop();
        dataSink.close();
        // stop and close the processor
        mediaProcessor.stop();
        mediaProcessor.close();
     * Sets the data source.  This is where the transmitter will get the media
     * to transmit.
    public void setDataSource(DataSource ds) throws IOException,
        NoProcessorException, CannotRealizeException, NoDataSinkException {
        /* Create the realized processor.  By calling the
           createRealizedProcessor() method on the manager, we are guaranteed
           that the processor is both configured and realized already. 
           For this reason, this method will block until both of these
           conditions are true.  In general, the processor is responsible
           for reading the file from a file and converting it to
           an RTP stream.
        mediaProcessor = Manager.createRealizedProcessor(
            new ProcessorModel(ds, FORMATS, CONTENT_DESCRIPTOR));
        /* Create the data sink.  The data sink is used to do the actual work
           of broadcasting the RTP data over a network.
        dataSink = Manager.createDataSink(mediaProcessor.getDataOutput(),
                                          mediaLocator);
     * Prints a usage message to System.out for how to use this class
     * through the command line.
    public static void printUsage() {
        System.out.println("Usage: java MediaTransmitter mediaLocator " +
                           "mediaFile");
        System.out.println("  example: java MediaTransmitter " +
            "rtp://192.168.1.72:49150/audio mysong.mp3");
        System.out.println("  example: java MediaTransmitter " +
            "rtp://192.168.1.255:49150/audio mysong.mp3");
     * Allows the user to run the class through the command line.
     * Only two arguments are allowed; these are the output media
     * locator and the mp3 audio file which will be broadcast
     * in the order.
    public static void main(String[] args) {
        try {
            if (args.length == 2) {
                MediaLocator locator = new MediaLocator(args[0]);
                MediaTransmitter transmitter = new MediaTransmitter(locator);
                System.out.println("-> Created media locator: '" +
                                   locator + "'");
                /* Creates and uses a file reference for the audio file,
                   if a url or any other reference is desired, then this
                   line needs to change.
                File mediaFile = new File(args[1]);
                DataSource source = Manager.createDataSource(
                    new MediaLocator(mediaFile.toURL()));
                System.out.println("-> Created data source: '" +
                                   mediaFile.getAbsolutePath() + "'");
                // set the data source.
                transmitter.setDataSource(source);
                System.out.println("-> Set the data source on the transmitter");
                // start transmitting the file over the network.
                transmitter.startTransmitting();
                System.out.println("-> Transmitting...");
                System.out.println("   Press the Enter key to exit");
                // wait for the user to press Enter to proceed and exit.
                System.in.read();
                System.out.println("-> Exiting");
                transmitter.stopTransmitting();
            } else {
                printUsage();
        } catch (Throwable t) {
            t.printStackTrace();
        System.exit(0);

Answer 1

Okay, here's the it copied out.
Media Transmitter
C:\John\Masters Project\Java\jmf1\MediaPlayer>java MediaTransmitter rtp://127.0.
0.1:2000/audio it-came-upon.mp3
-> Created media locator: 'rtp://127.0.0.1:2000/audio'
-> Created data source: 'C:\John\Masters Project\Java\jmf1\MediaPlayer\it-came-u
pon.mp3'
streams is [Lcom.sun.media.multiplexer.RawBufferMux$RawBufferSourceStream;@1decd
ec : 1
sink: setOutputLocator rtp://127.0.0.1:2000/audio
-> Set the data source on the transmitter
-> Transmitting...
   Press the Enter key to exit
MediaPlayerFrame
C:\John\Masters Project\Java\jmf1\MediaPlayer>java MediaPlayerFrame rtp://127.0.
0.1:2000/audio
MediaPlayerFrame
setMediaLocator: rtp://127.0.0.1:2000/audioAs I said, it just kinda stops there, what it should be doing is opening the MediaPlayer.
"MediaPlayerFrame" and "setMediaLocator: rtp://127.0.0.1:2000/audio" are just print outs I used to track here the code is getting to.