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 */