J'utilise AudioRecord pour enregistrer des données PCM 16 bits dans Android. Après avoir enregistré les données et les avoir enregistrées dans un fichier, je les ai relues pour les enregistrer en tant que fichier .wav.
Le problème est que les fichiers WAV sont reconnus par les lecteurs multimédias mais ne jouent que du bruit pur. Ma meilleure supposition pour le moment est que mes en-têtes de fichiers wav sont incorrects mais je n'ai pas pu voir quel est exactement le problème. (Je pense que c'est parce que je peux lire les données PCM brutes que j'ai enregistrées dans Audacity)
Voici mon code pour lire le fichier PCM brut et l'enregistrer en tant que .wav:
private void properWAV(File fileToConvert, float newRecordingID){
try {
long mySubChunk1Size = 16;
int myBitsPerSample= 16;
int myFormat = 1;
long myChannels = 1;
long mySampleRate = 22100;
long myByteRate = mySampleRate * myChannels * myBitsPerSample/8;
int myBlockAlign = (int) (myChannels * myBitsPerSample/8);
byte[] clipData = getBytesFromFile(fileToConvert);
long myDataSize = clipData.length;
long myChunk2Size = myDataSize * myChannels * myBitsPerSample/8;
long myChunkSize = 36 + myChunk2Size;
OutputStream os;
os = new FileOutputStream(new File("/sdcard/onefile/assessor/OneFile_Audio_"+ newRecordingID+".wav"));
BufferedOutputStream bos = new BufferedOutputStream(os);
DataOutputStream outFile = new DataOutputStream(bos);
outFile.writeBytes("RIFF"); // 00 - RIFF
outFile.write(intToByteArray((int)myChunkSize), 0, 4); // 04 - how big is the rest of this file?
outFile.writeBytes("WAVE"); // 08 - WAVE
outFile.writeBytes("fmt "); // 12 - fmt
outFile.write(intToByteArray((int)mySubChunk1Size), 0, 4); // 16 - size of this chunk
outFile.write(shortToByteArray((short)myFormat), 0, 2); // 20 - what is the audio format? 1 for PCM = Pulse Code Modulation
outFile.write(shortToByteArray((short)myChannels), 0, 2); // 22 - mono or stereo? 1 or 2? (or 5 or ???)
outFile.write(intToByteArray((int)mySampleRate), 0, 4); // 24 - samples per second (numbers per second)
outFile.write(intToByteArray((int)myByteRate), 0, 4); // 28 - bytes per second
outFile.write(shortToByteArray((short)myBlockAlign), 0, 2); // 32 - # of bytes in one sample, for all channels
outFile.write(shortToByteArray((short)myBitsPerSample), 0, 2); // 34 - how many bits in a sample(number)? usually 16 or 24
outFile.writeBytes("data"); // 36 - data
outFile.write(intToByteArray((int)myDataSize), 0, 4); // 40 - how big is this data chunk
outFile.write(clipData); // 44 - the actual data itself - just a long string of numbers
outFile.flush();
outFile.close();
} catch (IOException e) {
e.printStackTrace();
}
}
private static byte[] intToByteArray(int i)
{
byte[] b = new byte[4];
b[0] = (byte) (i & 0x00FF);
b[1] = (byte) ((i >> 8) & 0x000000FF);
b[2] = (byte) ((i >> 16) & 0x000000FF);
b[3] = (byte) ((i >> 24) & 0x000000FF);
return b;
}
// convert a short to a byte array
public static byte[] shortToByteArray(short data)
{
/*
* NB have also tried:
* return new byte[]{(byte)(data & 0xff),(byte)((data >> 8) & 0xff)};
*
*/
return new byte[]{(byte)(data & 0xff),(byte)((data >>> 8) & 0xff)};
}
Je n'ai pas inclus getBytesFromFile () car il prend trop de place et c'est une méthode éprouvée. Quoi qu'il en soit, voici le code qui fait l'enregistrement proprement dit:
public void run() {
Log.i("ONEFILE", "Starting main audio capture loop...");
int frequency = 22100;
int channelConfiguration = AudioFormat.CHANNEL_CONFIGURATION_MONO;
int audioEncoding = AudioFormat.ENCODING_PCM_16BIT;
final int bufferSize = AudioRecord.getMinBufferSize(frequency, channelConfiguration, audioEncoding);
AudioRecord audioRecord = new AudioRecord(MediaRecorder.AudioSource.MIC, frequency, channelConfiguration, audioEncoding, bufferSize);
audioRecord.startRecording();
ByteArrayOutputStream recData = new ByteArrayOutputStream();
DataOutputStream dos = new DataOutputStream(recData);
short[] buffer = new short[bufferSize];
audioRecord.startRecording();
while (!stopped) {
int bufferReadResult = audioRecord.read(buffer, 0, bufferSize);
for(int i = 0; i < bufferReadResult;i++) {
try {
dos.writeShort(buffer[i]);
} catch (IOException e) {
e.printStackTrace();
}
}
}
audioRecord.stop();
try {
dos.flush();
dos.close();
} catch (IOException e1) {
e1.printStackTrace();
}
audioRecord.stop();
byte[] clipData = recData.toByteArray();
File file = new File(audioOutputPath);
if(file.exists())
file.delete();
file = new File(audioOutputPath);
OutputStream os;
try {
os = new FileOutputStream(file);
BufferedOutputStream bos = new BufferedOutputStream(os);
DataOutputStream outFile = new DataOutputStream(bos);
outFile.write(clipData);
outFile.flush();
outFile.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
Veuillez suggérer ce qui pourrait mal tourner.
Je lutte avec cette même question depuis des heures maintenant, et mon problème était principalement que lors de l'enregistrement en 16 bits, vous devez faire très attention à ce que vous écrivez sur la sortie. Le fichier WAV attend les données au format Little Endian, mais l'utilisation de writeShort les écrit dans la sortie en tant que Big Endian. J'ai également obtenu des résultats intéressants en utilisant les autres fonctions, je suis donc retourné à l'écriture d'octets dans le bon ordre et cela fonctionne.
J'ai beaucoup utilisé un éditeur Hex lors du débogage. Je peux vous recommander de faire de même. De plus, l'en-tête dans la réponse ci-dessus fonctionne, je l'ai utilisé pour vérifier par rapport à mon propre code et cet en-tête est plutôt infaillible.
Comme l'en-tête est préoccupant, j'avais suivi ce code (si cela vous aide d'une manière ou d'une autre).
byte[] header = new byte[44];
header[0] = 'R'; // RIFF/WAVE header
header[1] = 'I';
header[2] = 'F';
header[3] = 'F';
header[4] = (byte) (totalDataLen & 0xff);
header[5] = (byte) ((totalDataLen >> 8) & 0xff);
header[6] = (byte) ((totalDataLen >> 16) & 0xff);
header[7] = (byte) ((totalDataLen >> 24) & 0xff);
header[8] = 'W';
header[9] = 'A';
header[10] = 'V';
header[11] = 'E';
header[12] = 'f'; // 'fmt ' chunk
header[13] = 'm';
header[14] = 't';
header[15] = ' ';
header[16] = 16; // 4 bytes: size of 'fmt ' chunk
header[17] = 0;
header[18] = 0;
header[19] = 0;
header[20] = 1; // format = 1
header[21] = 0;
header[22] = (byte) channels;
header[23] = 0;
header[24] = (byte) (longSampleRate & 0xff);
header[25] = (byte) ((longSampleRate >> 8) & 0xff);
header[26] = (byte) ((longSampleRate >> 16) & 0xff);
header[27] = (byte) ((longSampleRate >> 24) & 0xff);
header[28] = (byte) (byteRate & 0xff);
header[29] = (byte) ((byteRate >> 8) & 0xff);
header[30] = (byte) ((byteRate >> 16) & 0xff);
header[31] = (byte) ((byteRate >> 24) & 0xff);
header[32] = (byte) (2 * 16 / 8); // block align
header[33] = 0;
header[34] = RECORDER_BPP; // bits per sample
header[35] = 0;
header[36] = 'd';
header[37] = 'a';
header[38] = 't';
header[39] = 'a';
header[40] = (byte) (totalAudioLen & 0xff);
header[41] = (byte) ((totalAudioLen >> 8) & 0xff);
header[42] = (byte) ((totalAudioLen >> 16) & 0xff);
header[43] = (byte) ((totalAudioLen >> 24) & 0xff);
out.write(header, 0, 44);
Êtes-vous certain de l'ordre des octets? "RIFF", "WAV", "fmt" et "data" ont l'air bien, mais les nombres dans l'en-tête peuvent devoir être d'un ordre différent (petit endian contre gros endian). Vous n'avez pas non plus besoin de convertir manuellement en octets à l'aide de votre méthode intToByteArray
. Vous pouvez utiliser les méthodes writeInt
et writeShort
de DataOutputStream
. Pour le premier, cela ressemblerait à quelque chose comme:
outFile.writeInt(Integer.reverseBytes((int)myChunkSize));
Pour le short, ce serait comme:
outFile.writeShort(Short.reverseBytes((short)myFormat))
De cette façon, vous n'avez pas non plus besoin de fournir le décalage et la longueur (0, 4)
Nombres. C'est bien.
Comme Ronald Kunenborg le dit correctement, le problème est la conversion Litte Endian/Big Endian.
La manière la plus simple est d'écrire une aide courte comme celle-ci:
public static void writeShortLE(DataOutputStream out, short value) {
out.writeByte(value & 0xFF);
out.writeByte((value >> 8) & 0xFF);
}
Ceci est très utile si vous enregistrez de l'audio dans un fichier wave avec Android et vous avez également besoin du tableau court.
(Crédits: https://stackoverflow.com/a/1394839/1686216 )