[Resolvido] Problemas com JMF execeção de 'Format of Stream not supported in RTP Session...'

package br.org.multimidiasi.motor;

import java.awt.Dimension;
import java.io.IOException;
import java.util.Calendar;

import javax.media.DataSink;
import javax.media.Format;
import javax.media.MediaLocator ;
import javax.media.NoDataSinkException;
import javax.media.NoProcessorException;
import javax.media.NotConfiguredError;
import javax.media.NotRealizedError;
import javax.media.Processor;
import javax.media.Manager ;
import javax.media.control.FormatControl;
import javax.media.control.TrackControl;
import javax.media.format.AudioFormat;
import javax.media.format.VideoFormat;
import javax.media.protocol.ContentDescriptor ;

public class Servidor {

    private MediaLocator ml;
    private Processor pro;
    private javax.media.protocol.DataSource ds;
    private DataSink dsk;
    private boolean codificado = false;
    
    
    public void iniciarServicoServidor(String end,String ip, int porta)
    {
        try {
            capturarMidia(end);
            criarProcessor();
            configurarProcessor();
            descreverConteudoEnviado();
            //formatarEmProtocoloRTP();
            formatRTP();
            
            criarStreaming();
            configurarServidor(ip, porta);
            iniciarServidor();
        } catch (RuntimeException e) {
            System.out.println("Houve um erro em iniciarServicoServidor");
            e.printStackTrace();
        }
    }
    
    public void capturarMidia(String endereco)
    {
        try {
            System.out.println("**************************************************************");
            System.out.println("Iniciando processo de servidor de multimidia em " + Calendar.getInstance().getTime().toString());
            ml = new MediaLocator("file:///" + endereco);
            System.out.println("Midia realizada com sucesso.");
            System.out.println ("[" + "file:///" + endereco +"]");
            
        } catch (RuntimeException e) {
            System.out.println("Houve um erro em capturarMidia");
            e.printStackTrace ();
        }
    }
    
    public void criarProcessor()
    {
        try {
            System.out.println("**************************************************************");
            pro = Manager.createProcessor(ml);
            System.out.println("Processor criado com sucesso.");
            System.out.println("Midia com durcao:" + pro.getDuration().getSeconds());
            
        } catch (NoProcessorException e) {
            System.out.println("Houve um erro em criarProcessor");
            e.printStackTrace();
        } catch (IOException e) {
            System.out.println ("Houve um erro em criarProcessor");
            e.printStackTrace();
        }
    }

    public void configurarProcessor()
    {
        try {
            System.out.println("**************************************************************");
            System.out.println("Processor em estado de configuração.");
            pro.configure();
            System.out.println("Processor configurado.");
        } catch (RuntimeException e) {
            System.out.println("Houve um erro em configurarProcessor");
            e.printStackTrace();
        }
    }
    
    public void descreverConteudoEnviado()
    {
        try {
            System.out.println("**************************************************************");        
            pro.setContentDescriptor(new ContentDescriptor(ContentDescriptor.RAW));
             System.out.println("Descritor de conteudo:" + pro.getContentDescriptor().toString());
        } catch (NotConfiguredError e) {
            System.out.println("Houve um erro em descreverConteudoEnviado");
            e.printStackTrace();
        }
    }
    
    private Format checkForVideoSizes(Format original, Format supported) {

        int width, height;
        Dimension size = ((VideoFormat)original).getSize();
        Format jpegFmt = new Format(VideoFormat.JPEG_RTP);
        Format h263Fmt = new Format(VideoFormat.H263_RTP);

        if (supported.matches(jpegFmt)) {
            // For JPEG, make sure width and height are divisible by 8.
            width = (size.width % 8 == 0 ? size.width :
                    (int)(size.width / 8) * 8);
            height = (size.height % 8 == 0 ? size.height :
                    (int)(size.height / 8) * 8);
        } else if (supported.matches(h263Fmt)) {
            // For H.263, we only support some specific sizes.
            if (size.width < 128) {
            width = 128;
            height = 96;
            } else if ( size.width < 176) {
            width = 176;
            height = 144;
            } else {
            width = 352;
            height = 288;
            }
        } else {
            // We don't know this particular format.  We'll just
            // leave it alone then.
            return supported;
        }

        return (new VideoFormat(null,
                    new Dimension(width, height),
                    Format.NOT_SPECIFIED ,
                    null,
                    Format.NOT_SPECIFIED)).intersects(supported);
        }

    
    
    public void formatRTP()
    {
        try {
            // Program the tracks.
            TrackControl tracks[] = pro.getTrackControls();
            Format supported[];
            Format chosen;
            
            for (int i = 0; i < tracks.length; i++) {
                Format format = tracks[i].getFormat();
                if (tracks[i].isEnabled()) {

                supported = tracks[i].getSupportedFormats();

                // We've set the output content to the RAW_RTP.
                // So all the supported formats should work with RTP.
                // We'll just pick the first one.

                if (supported.length > 0) {
                    if (supported[0] instanceof VideoFormat) {
                    // For video formats, we should double check the
                    // sizes since not all formats work in all sizes.
                    chosen = checkForVideoSizes(tracks[i].getFormat(),
                                    supported[0]);
                    } else
                    chosen = supported[0];
                    tracks[i].setFormat(chosen);
                    System.err.println("Track " + i + " is set to transmit as:");
                    System.err.println("  " + chosen);
                    codificado = true;
                } else
                    tracks[i].setEnabled(false);
                } else
                tracks[i].setEnabled(false);
            }
        } catch (RuntimeException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    
    public void formatarEmProtocoloRTP()
    {
        System.out.println("**************************************************************");
        try {
            
            System.out.println("Codificado (encode) para pacote RTP.");
            TrackControl faixa[] = pro.getTrackControls();
            
            System.out.println("Codificando " + faixa.length + " faixas.");
            for (int i = 0; i < faixa.length ; i++)
            {
                
                System.out.println("Codificando " + (i+1) + " de " + faixa.length);
                
                if (!codificado && faixa[i] instanceof FormatControl)
                {
                    if (((FormatControl)faixa[i]).
                            setFormat(new AudioFormat(AudioFormat.GSM_RTP,
                                    800,
                                    8,
                                    1))== null)
                        
                    {
                        System.out.println("Nao foi possivel codificar a faixa :" + (i+1));
                        faixa[i].setEnabled(false);
                    }
                    else
                    {
                        System.out.println("Faixa [" + (i+1) + "] foi codificada em 'RTP'");
                        codificado = true;
                    }
                    
                }
                else
                {
                    System.out.println("Nao foi possivel codificar a faixa :" + (i+1));
                     System.out.println("Ja esta codificado ou nao eh uma instancia de FormatControl");
                    faixa[i].setEnabled(false);
                }
                }
        } catch (NotConfiguredError e) {
            System.out.println("Houve um erro em formatarMidia");
            e.printStackTrace();
        }
        
        }
    
    public void tocar()
    {
        pro.start();
            
    }
    
    public void criarStreaming()
    {
        
        try {
            System.out.println("**************************************************************");
            if (codificado)
            {
                System.out.println("Midia codificada...");
                System.out.println("Processor entra em estado de realize.");
                 pro.realize();
                System.out.println("Processor realized.");
                System.out.println("Adquirindo o streaming a ser enviado.");
                ds = pro.getDataOutput();
                System.out.println("Streaming adquirido pronto a ser enviado.");
                
            }
        } catch (NotRealizedError e) {
            System.out.println("Houve um erro em criarStreaming");
            System.out.println(e.getMessage());
            e.printStackTrace();
        }
        catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
    
    public void configurarServidor(String ip, int porta)
    {
        System.out.println("**************************************************************");
        String url = "rtp://" + ip + ":" + porta + "/audio/1";
         System.out.println("Servidor ira atender em " + url);
        
        
        MediaLocator mml = new MediaLocator(url);
        
        System.out.println("Localizador de midia ja criado");
        try {
            System.out.println("Criando um DataSink a ser enviado.");
            dsk = Manager.createDataSink(ds, mml);
            System.out.println("DataSink criado.");
        } catch (NoDataSinkException e) {
            e.printStackTrace();
        }
        
    }

    public void iniciarServidor()
    {
        try {
            System.out.println("**************************************************************");
            dsk.open();
            System.out.println("Servidor ligado.");
            dsk.start();
            
            System.out.println("Servidor iniciado.");
            
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
    
    
}

Servidor srv = new Servidor();
srv.iniciarServicoServidor("c:\\radio.wav","127.0.0.1","22000");