[Problema] Java Sound API + JMF

Estou com a seguinte classe e toda vez que eu vou executa-la mesmo tendo dispositivo de audio ela cai no "No capture devices found", eu encontrei essa classe num tutorial de jmf e Java sound api.

Se alguem puder da uma mão ae:

/* Pacotes do núcleo de Java */

import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import java.util.Vector;

import javax.media.CannotRealizeException;
import javax.media.CaptureDeviceInfo;
import javax.media.CaptureDeviceManager;
import javax.media.DataSink;
import javax.media.Format;
import javax.media.Manager;
import javax.media.MediaLocator;
import javax.media.NoDataSinkException;
import javax.media.NoDataSourceException;
import javax.media.NoProcessorException;
import javax.media.Processor;
import javax.media.ProcessorModel;
import javax.media.control.FormatControl;
import javax.media.control.MonitorControl;
import javax.media.datasink.DataSinkEvent;
import javax.media.datasink.DataSinkListener;
import javax.media.datasink.EndOfStreamEvent;
import javax.media.protocol.CaptureDevice;
import javax.media.protocol.DataSource;
import javax.media.protocol.FileTypeDescriptor;
import javax.swing.JButton;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JPanel;

/* Apresenta e salva a mídia capturada. */

public class CapturePlayer extends JFrame {

private static final long serialVersionUID = 1L;
	private JButton captureButton; /* botões de captura e salvamento */
	private Component saveProgress; /* componente GUI para salvar os dados capturados */
	private Format formats[], selectedFormat; /* formatos da mídia do dispositivo, formato escolhido pelo usuário */
	private FormatControl formatControls[]; /* controles dos formatos de mídia do dispositivo */
	private CaptureDeviceInfo deviceInfo; /* informações de especificação do dispositivo */
	private Vector deviceList; /* Vector contendo todas as informações do dispositivo */
	private DataSource inSource, outSource; /* fontes de dados de entrada e saída */
	private DataSink dataSink; /* gravador do arquivo para a mídia capturada */
	private Processor processor; /* Processor para gerar e salvar a mídia capturada */

public CapturePlayer() { /* construtor para CapturePlayer */
		super("Capture Player");
		JPanel buttonPanel = new JPanel(); /* painel contendo botões */
		getContentPane().add(buttonPanel);
		captureButton = new JButton("Capture and Save File"); /* botão para acessar e inicializar dispositivos de captura */
		buttonPanel.add(captureButton, BorderLayout.CENTER);
		captureButton.addActionListener(new CaptureHandler()); /* registra um ActionListener para eventos do captureButton */
		Manager.setHint(Manager.LIGHTWEIGHT_RENDERER, Boolean.TRUE); /* ativa a geração leve para tornar compatível com componentes GUI peso leve */
		addWindowListener(new WindowAdapter() { /* registra um WindowListener para eventos da frame */
			public void windowClosing(WindowEvent windowEvent) { /* classe interna anônima para tratar WindowEvents descarta o Processor */
				if (processor != null)
					processor.close();
			}
		} /* fim de WindowAdapter */
		); /* fim da chamada para o método addWindowListener */
	} /* fim do construtor */

private class CaptureHandler implements ActionListener { /* classe tratadora de ações para configurar dispositivo */

public void actionPerformed(ActionEvent actionEvent) { /* inicializa e configura dispositivo de captura */
			deviceList = CaptureDeviceManager.getDeviceList(null); /* coloca as informações disponíveis do dispositivo no Vector */
			if ((deviceList == null) || (deviceList.size() == 0)) { /* se nenhum dispositivo for encontrado, exibe mensagem de erro */
				showErrorMessage("No capture devices found!");
				return;
			}
			String deviceNames[] = new String[deviceList.size()]; /* array de nomes de dispositivos */
			
			for (int i = 0; i < deviceList.size(); i++) { /* armazena todos os nomes de dispositivos em um array de strings, para fins de exibição */
				deviceInfo = (CaptureDeviceInfo) deviceList.elementAt(i);
				deviceNames[i] = deviceInfo.getName();
			}
			
			int selectDeviceIndex = getSelectedDeviceIndex(deviceNames); /* obtém o índice no Vector do dispositivo selecionado */
			
			if (selectDeviceIndex == -1){
				return;
			}
			
			deviceInfo = (CaptureDeviceInfo) deviceList.elementAt(selectDeviceIndex); /* obtém as informações de dispositivo do dispositivo selecionado */
			formats = deviceInfo.getFormats();
			
			if (inSource != null){ /* se o dispositivo de captura anterior estiver aberto, desconecta-o */
				inSource.disconnect();
			}
			try { /* obtém dispositivo e configura seu formato */
				inSource = Manager.createDataSource(deviceInfo.getLocator()); /* cria fonte de dados a partir do MediaLocator do dispositivo */
				formatControls = ((CaptureDevice) inSource).getFormatControls(); /* obtém controles de configuração de formato para o dispositivo */
				selectedFormat = getSelectedFormat(formats); /* obtém a configuração de formato do dispositivo desejada pelo usuário */
				
				if (selectedFormat == null){
					return;
				}
				
				setDeviceFormat(selectedFormat);
				captureSaveFile();
			} catch (NoDataSourceException noDataException) { /* não consegue encontrar DataSource a partir do MediaLocator */ 
				noDataException.printStackTrace(); 
			} catch (IOException ioException) { /* erro de conexão ao dispositivo */
				ioException.printStackTrace();
			}
		} /* fim do método actionPerformed */
	} /* fim da classe interna CaptureHandler */

public void setDeviceFormat(Format currentFormat) { /* configura o formato de saída da mídia capturada pelo dispositivo */
		for (int i = 0; i < formatControls.length; i++) { /* configura formato desejado em todos os controles de formato */
			if (formatControls[i].isEnabled()) { /* assegura que o controle de formato pode ser configurado */
				formatControls[i].setFormat(currentFormat);
				System.out.println("Presentation output format currently set as " + formatControls[i].getFormat());
			}
		} /* fim do laço for */
	}

public int getSelectedDeviceIndex(String[] names) { /* obtém o índice no Vector do dispositivo selecionado */
		String name = (String) JOptionPane.showInputDialog(this, "Select a device:", "Device Selection", JOptionPane.QUESTION_MESSAGE, null, names, names[0]); /* obtém o nome do dispositivo da caixa de diálogo de seleção de dispositivo */
		
		if (name != null) { /* se o formato foi selecionado, obtém índice do nome no array names */
			return Arrays.binarySearch(names, name);
		} else { /* senão, devolve valor indicando seleção inválida */
			return -1;
		}
	}

public Format getSelectedFormat(Format[] showFormats) { /* devolve formato selecionado pelo usuário para o dispositivo */
		return (Format) JOptionPane.showInputDialog(this, "Select a format: ", "Format Selection", JOptionPane.QUESTION_MESSAGE, null, showFormats, null);
	}

public void showErrorMessage(String error) { /* exibe mensagens de erro */
		JOptionPane.showMessageDialog(this, error, "Error", JOptionPane.ERROR_MESSAGE);
	}

public File getSaveFile() { /* obtém arquivo desejado para salvar a mídia capturada */
		JFileChooser fileChooser = new JFileChooser();
		fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
		int result = fileChooser.showSaveDialog(this);

if (result == JFileChooser.CANCEL_OPTION){
			return null;
		}else {
			return fileChooser.getSelectedFile();
		}
	}

public void showSaveMonitor() { /* mostra o monitor de salvamento dos dados capturados */
		int result = JOptionPane.showConfirmDialog(this, saveProgress, "Save capture in progress...", JOptionPane.DEFAULT_OPTION, JOptionPane.INFORMATION_MESSAGE); /* mostra o diálogo do monitor de salvamento */
		
		if ((result == JOptionPane.OK_OPTION) || (result == JOptionPane.CLOSED_OPTION)) { /* termina salvamento se o usuário pressiona "OK" ou fecha diálogo */
			processor.stop();
			processor.close();
			System.out.println("Capture closed.");
		}
	}

public void captureSaveFile() { /* processa mídia capturada e salvada no arquivo */
		Format outFormats[] = new Format[1]; /* array de formatos desejados de salvamento suportados pelas trilhas */
		outFormats[0] = selectedFormat;
		FileTypeDescriptor outFileType = new FileTypeDescriptor(FileTypeDescriptor.QUICKTIME); /* formato de saída no arquivo */

try { /* configura e inicia processador e monitora a captura */
			processor = Manager.createRealizedProcessor(new ProcessorModel(inSource, outFormats, outFileType)); /* cria processador a partir do modelo de processador da fonte de dados específica, formatos de saída nas trilhas e formato de saída no arquivo */
			
			if (!makeDataWriter()) { /* tenta criar um gravador de dados para a saída de mídia */
				return;
			}

processor.start(); /* chama start do processador para iniciar alimentação dos dados capturados */
			MonitorControl monitorControl = (MonitorControl) processor.getControl("javax.media.control.MonitorControl"); /* obtém controle de monitor para captura e codificação */
			saveProgress = monitorControl.getControlComponent(); /* obtém componente GUI do controle de monitoração */
			showSaveMonitor();
		} catch (NoProcessorException processorException) { /* nenhum processador pode ser encontrado para uma fonte de dados específica */
			processorException.printStackTrace();
		} catch (CannotRealizeException realizeException) { /* incapaz de realizar através do método createRealizedProcessor */
			realizeException.printStackTrace();
		} catch (IOException ioException) { /* erro de conexão ao dispositivo */
			ioException.printStackTrace();
		}

} /* fim do método captureSaveFile */

public boolean makeDataWriter() { /* método que inicializa o gravador do arquivo de mídia */
		File saveFile = getSaveFile();

if (saveFile == null){
			return false;
		}
		
		outSource = processor.getDataOutput(); /* obtém fonte de dados de saída a partir do processador */

if (outSource == null) {
			showErrorMessage("No output from processor!");
			return false;
		}

try { /* inicia o processo de gravação de dados */
			MediaLocator saveLocator = new MediaLocator(saveFile.toURL()); /* cria um novo MediaLocator a partir do URL saveFile */
			dataSink = Manager.createDataSink(outSource, saveLocator); /* cria DataSink a partir da fonte de dados de saída e do arquivo de destino de salvamento especificado pelo usuário */
			
			dataSink.addDataSinkListener( /* registra um DataSinkListener para DataSinkEvents */
					new DataSinkListener() { /* classe interna anônima para tratar DataSinkEvents */
						public void dataSinkUpdate(DataSinkEvent dataEvent) { /* se fim da mídia, fecha o gravador de dados */
							if (dataEvent instanceof EndOfStreamEvent) { /* se a captura foi parada, fecha DataSink */
								dataSink.close();
							}
						}
					} /* fim de DataSinkListener */
			); /* fim da chamada ao método addDataSinkListener */
			dataSink.open(); /* começa a salvar */
			dataSink.start();

} catch (NoDataSinkException noDataSinkException) { /* DataSink não pode ser encontrada para o arquivo de salvamento e a fonte de dados específicos */
			noDataSinkException.printStackTrace();
			return false;
		} catch (SecurityException securityException) { /* violação enquanto acessava destino de MediaLocator */
			securityException.printStackTrace();
			return false;
		} catch (IOException ioException) { /* problema na abertura e inicialização de DataSink */
			ioException.printStackTrace();
			return false;
		}
		return true;

} /* fim do método makeDataWriter */

public static void main(String args[]) { /* método main */
		CapturePlayer testPlayer = new CapturePlayer();
		testPlayer.setSize(200, 70);
		testPlayer.setLocation(300, 300);
		testPlayer.setDefaultCloseOperation(EXIT_ON_CLOSE);
		testPlayer.setVisible(true);
	}

} /* fim da classe CapturePlayer */

Eu estou tentando aprender JMF também,

você pode passar a apostila que você está utilizando?

valeu

Bird89du wrote:Eu estou tentando aprender JMF também,

você pode passar a apostila que você está utilizando?

valeu

Me manda um e-mail que eu te respondo com ela:

Vlw!

Pelo debug ele pega esse trecho de código:

Só que não entendi porque vai null ali! sendo que é pra i um format!

Tbm não saberia dizer que é o format.. li só por cima...
se alguem souber ai!?

Eu consegui fazer uma aplicação que tira fotos pela webcam,

para achar o hardware eu utilizei um parâmetro genérico,será que não é isso?

ml = new MediaLocator("vfw://0");

vou mandar o email

valeu

Bird89du wrote:Eu consegui fazer uma aplicação que tira fotos pela webcam,

para achar o hardware eu utilizei um parâmetro genérico,será que não é isso?

ml = new MediaLocator("vfw://0");

vou mandar o email

valeu

N sei se ali no format eu nao tenho que coloca o formato a ser criado! mais dai no exemplo nao taria se setando para null!

Eu achei alguma coisa no site da sun

dá uma olhada
http://forums.sun.com/thread.jspa?threadID=525026

espero que ajude

Cheguei a dar uma olhada! mais nada que brilhasse a mente hahaha!

HelloWorld Membro desde: 07/08/2009 02:08:17 Mensagens: 13 Offline

Fala ae pesoal,

Não se vcs já resolveram o problema! De qualquer modo vamos ver se isso ajuda!

- Se vc instalou o JMF, no pacote de programas instalados tem o JMF Registry que possue todos os dispositivos de captura de audio e video encontrado por ele.

Se vc nã encontrar um dispositivo, execute o comando de auto detect para ele encontrar o hardware.

Pelo que ví do comando em seu código o mesmo está legal e é assim que o meu funciona aqui, só que ele encontra o dispositivo da We bCam!

Sds

André Menegussi

Notícias, artigos e o maior fórum brasileiro sobre Java