android音频录制未播放整个PCM文件

我已使用录制PCM文件

try {

        DataOutputStream dos = new DataOutputStream(
                new BufferedOutputStream(
                        new FileOutputStream(recordingFile)));

        int bufferSize = AudioRecord.getMinBufferSize(frequency,
                channelConfiguration, audioEncoding);

        AudioRecord audioRecord = new AudioRecord(
                MediaRecorder.AudioSource.MIC, frequency,
                channelConfiguration, audioEncoding, bufferSize);

        AudioTrack audioPlayer = new AudioTrack(AudioManager.STREAM_MUSIC,
                frequency, AudioFormat.CHANNEL_OUT_STEREO, audioEncoding,
                bufferSize, AudioTrack.MODE_STREAM);

        short[] buffer = new short[blockSize];
        double[] toTransform = new double[blockSize];
        int readBytes = 0;
        int writtenBytes = 0;

        audioRecord.startRecording();
        audioPlayer.play();

        AudioManager audioManager = (AudioManager) ctx
                .getSystemService(Context.AUDIO_SERVICE);

        while (started) {
            int bufferReadResult = audioRecord.read(buffer, 0, blockSize);

            for (int i = 0; i < blockSize && i < bufferReadResult; i++) {
                toTransform[i] = (double) buffer[i] / 32768.0; // signed
                // 16
                dos.writeShort(buffer[i]);

            } // bit

            // filterAudio(bufferSize, toTransform, frequency);
            transformer.ft(toTransform);
            publishProgress(toTransform);

            // capture data and record to file

            if (audioManager.isWiredHeadsetOn()) {
                if (audioPlayer.getPlayState() != AudioTrack.PLAYSTATE_PLAYING) {
                    audioPlayer.play();
                }
                if (AudioRecord.ERROR_INVALID_OPERATION != bufferReadResult) {
                    writtenBytes += audioPlayer.write(buffer, 0,
                            bufferReadResult);
                }
            } else {
                if (audioPlayer.getPlayState() == AudioTrack.PLAYSTATE_PLAYING) {
                    audioPlayer.pause();
                }
            }

        }

        audioRecord.stop();
        audioPlayer.stop();
        audioRecord.release();
        audioPlayer.release();
        try {
            dos.close();
        } catch (Exception e) {
            e.printStackTrace();
        }

    } catch (Throwable t) {
        t.printStackTrace();
        Log.e("AudioRecord", "Recording Failed");
    }

    return null;

试试看{
DataOutputStream dos=新的DataOutputStream(
新的缓冲输出流(
新的FileOutputStream（recordingFile））；
int bufferSize=AudioRecord.getMinBufferSize（频率，
信道配置、音频编码）；
音频记录=新的音频记录(
MediaRecorder.AudioSource.MIC，频率，
信道配置、音频编码、缓冲区大小）；
AudioTrack audioPlayer=新的AudioTrack（AudioManager.STREAM_MUSIC，
频率、音频格式、通道输出立体声、音频编码、，
缓冲区大小、音轨模式（U流）；
short[]buffer=新的short[blockSize]；
double[]toTransform=新的double[blockSize]；
int readBytes=0；
int writenbytes=0；
录音。开始录制（）；
audioPlayer.play（）；
AudioManager AudioManager=（AudioManager）ctx
.getSystemService（Context.AUDIO_服务）；
while（启动）{
int bufferReadResult=audioRecord.read（缓冲区，0，块大小）；
对于（int i=0；i

我通过以下方式播放：

private AsyncTask<Void, Void, Void> task = new AsyncTask<Void, Void, Void>() {

    @Override
    protected Void doInBackground(Void... params) {
        try {

            musicLength = (int) (recordedFile.length() / 2);
            music = new short[musicLength];

            InputStream is = new FileInputStream(recordedFile);
            BufferedInputStream bis = new BufferedInputStream(is);
            DataInputStream dis = new DataInputStream(bis);

            int i = 0;
            while (dis.available() > 0) {
                music[i] = dis.readShort();
                i++;
            }

            dis.close();

            audioTrackRecorded = new AudioTrack(AudioManager.STREAM_MUSIC,
                    frequency, AudioFormat.CHANNEL_CONFIGURATION_STEREO,
                    AudioFormat.ENCODING_PCM_16BIT, musicLength,
                    AudioTrack.MODE_STREAM);

            audioTrackRecorded.write(music, 0, musicLength);

        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    protected void onPostExecute(Void result) {
        progressBarLayout.setVisibility(View.GONE);
        seekbarLayout.setVisibility(View.VISIBLE);

        isInitialized = true;

    };
};

private AsyncTask task=new AsyncTask（）{
@凌驾
受保护的Void doInBackground（Void…参数）{
试一试{
musicLength=（int）（recordedFile.length（）/2）；
音乐=新短[音乐长度]；
InputStream is=新文件InputStream（recordedFile）；
BufferedInputStream bis=新的BufferedInputStream（is）；
DataInputStream dis=新的DataInputStream（bis）；
int i=0；
而（dis.available（）>0）{
音乐[i]=dis.readShort（）；
i++；
}
dis.close（）；
audioTrackRecorded=新的AudioTrack（AudioManager.STREAM_音乐，
频率、音频格式、频道、配置、立体声、，
AudioFormat.ENCODING_PCM_16位，音乐长度，
音频跟踪模式（音频流）；
录音。写入（音乐，0，音乐长度）；
}捕获（例外e）{
e、 printStackTrace（）；
}
返回null；
}
受保护的void onPostExecute（void结果）{
progressBarLayout.setVisibility（View.GONE）；
请参见barlayout.setVisibility（View.VISIBLE）；
isInitialized=true；
};
};

---

我在播放这个PCM时遇到问题，在播放过程中我只得到了一半。希望你能在这方面帮助我。谢谢。

这是我播放PCM音频文件的代码。。。享受：）

---

首先要检查的是：文件是否正常？如果您在计算机上播放它（例如Audacity），它是否包含您希望它包含的所有音频？下一步，将

audioEncoding

和

channelConfiguration

设置为什么？您是否有机会尝试以立体声播放单声道内容？我已经在PC中使用audacity播放了，pcm文件的播放也可以。我使用AudioFormat.CHANNEL\u CONFIGURATION\u立体声和AudioFormat.ENCODING\u PCM\u 16位。在录制和播放期间。

music.length

是否与文件读取循环后文件中的短片数量匹配？

audioTrackRecorder.write的返回值是否与此值匹配？感谢您的回答我已经通过修改musicLength=（int）（recordedFile.length（）/2）解决了我的问题；到musicLength=（int）recordedFile.length（）；
void playRecord() {

    audioTrack = null;

    File file = new File(AudioSavePathInDevice, NameAudio);

    int shortSizeInBytes = Short.SIZE/Byte.SIZE;

    final int bufferSizeInBytes = (int)(file.length()/shortSizeInBytes);

    final short[] audioData = new short[bufferSizeInBytes];

    try {
        InputStream inputStream = new FileInputStream(file);
        BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);
        DataInputStream dataInputStream = new DataInputStream(bufferedInputStream);

        int j = 0;
        while(dataInputStream.available() > 0){
            audioData[j] = dataInputStream.readShort();
            j++;

        }

        dataInputStream.close();


        audioTrack = new AudioTrack(3,
                11025,
                2,
                2,
                bufferSizeInBytes,
                1);

        audioTrack.play();
        audioTrack.write(audioData, 0, bufferSizeInBytes);


    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }

}