AudioRecode和AudioTrack(示例)

最新推荐文章于 2024-05-02 13:51:21 发布
最新推荐文章于 2024-05-02 13:51:21 发布
阅读量1.3k 收藏 2
点赞数
分类专栏： 自己的专业
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/telenewbie/article/details/78212855
版权 
package com.txz.test;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.util.Arrays;

import android.media.AudioFormat;
import android.media.AudioManager;
import android.media.AudioRecord;
import android.media.AudioTrack;
import android.media.MediaRecorder;
import android.os.Handler;
import android.os.Message;
import android.os.PowerManager;
import android.util.Log;

public class AudioRecThread implements
        android.media.AudioTrack.OnPlaybackPositionUpdateListener {
    final static String TAG = "AudioRecThread";
    static public final int MSG_AUDIO_REC_FINISH = 1;
    static public final int MSG_AUDIO_PLAY_FINISH = 2;
    private boolean audioRecContinue = false;
    private boolean audioPlayContinue = false;
    private PowerManager.WakeLock wl;
    private Thread thread;
    private long startPlayMilli = 0;
    private long playUpdatePeriodAmass = 0;
    private long timeMarkAttendModified = 0;
    private int markPos = 0;
    private int markMill = 200;


    private int updateTimes = 0;

    public void onPeriodicNotification(AudioTrack track) {
        if (track.getState()==AudioTrack.PLAYSTATE_PLAYING) {
            playUpdatePeriodAmass += 25;
            long c = System.currentTimeMillis();
            c -= startPlayMilli;
            c = track.getPlaybackHeadPosition();
            c /= 8;
            Log.v(TAG + " onPeriodicNotification", "real ms " + c
                    + " period total " + playUpdatePeriodAmass);
        }
    }

    public void onMarkerReached(AudioTrack track) {
        timeMarkAttendModified = System.currentTimeMillis();
        timeMarkAttendModified -= markMill;
        Log.v(TAG + " period currpos", "mark:" + markMill);
    }

    AudioRecThread(PowerManager.WakeLock wl1) {
        Log.v(TAG, "AvcThread created constructor1");
        wl = wl1;
    }

    void writeShort(RandomAccessFile fo, short in) throws IOException {
        byte tmp[] = { 0, 0 };
        tmp[0] = (byte) (in & 0xff);
        tmp[1] = (byte) ((in >> 8) & 0xff);
        try {
            fo.write(tmp);
        } catch (IOException e) {
            throw e;
        }
    }

    void writeInt(RandomAccessFile fo, int in) throws IOException {
        byte tmp[] = { 0, 0, 0, 0 };
        tmp[0] = (byte) (in & 0xff);
        tmp[1] = (byte) ((in >> 8) & 0xff);
        tmp[2] = (byte) ((in >> 16) & 0xff);
        tmp[3] = (byte) ((in >> 24) & 0xff);
        try {
            fo.write(tmp);
        } catch (IOException e) {
            throw e;
        }
    }

    void startAudioRec(final String audioFname, final int audioSource,
            final Handler handler) {

        final Runnable audioRecRun = new Runnable() {
            public void run() {

                int channel = AudioFormat.CHANNEL_IN_MONO;
                short channels = 1;
                int format = AudioFormat.ENCODING_PCM_16BIT;
                int bitsPerSample = 16;
                int sampleRate = 16000;
                int bufferSizeInBytes = AudioRecord.getMinBufferSize(
                        sampleRate, channel, format);

                AudioRecord audioRecord = new AudioRecord(audioSource,
                        sampleRate, channel, format, bufferSizeInBytes);
                if (audioRecord == null)
                    return;
                int bufReadLenInByte = bufferSizeInBytes / 2;
                byte[] bufRead = new byte[bufReadLenInByte];

                RandomAccessFile fo;
                wl.acquire();
                try {
                    fo = new RandomAccessFile(audioFname, "rw");
                } catch (FileNotFoundException e) {
                    return;
                } catch (IllegalArgumentException e) {
                    return;
                } catch (SecurityException e) {
                    return;
                }

                /*
                 * typedef struct tWAVEFORMATEX { WORD wFormatTag; WORD
                 * nChannels; DWORD nSamplesPerSec; DWORD nAvgBytesPerSec; WORD
                 * nBlockAlign; WORD wBitsPerSample; WORD cbSize; } WAVEFORMATEX
                 */
                int datalength = 0;

                try {
                    byte[] tmp = { 0, 0, 0, 0 };
                    fo.writeBytes("RIFF");
                    fo.writeInt(0); // Riff file length
                    fo.writeBytes("WAVE"); // 4
                    fo.writeBytes("fmt "); // 4
                    writeInt(fo, 16); // 4 , followed by 16 bytes
                    writeShort(fo, (short) 1);// pcm wave tag
                    writeShort(fo, (short) channels);
                    writeInt(fo, sampleRate);
                    writeInt(fo, bitsPerSample * sampleRate * channels / 8);
                    writeShort(fo, (short) (channels * bitsPerSample / 8));
                    writeShort(fo, (short) bitsPerSample);
                    fo.writeBytes("data"); // 4
                    fo.writeInt(0); // 4 ,data length
                } catch (IOException e) {

                }

                audioRecContinue = true;
                try {
                    audioRecord.startRecording();
                } catch (IllegalStateException e) {
                    e.printStackTrace();
                    audioRecContinue = false;
                }

                while (audioRecContinue) {
                    // Log.v(TAG+"-ENC","In run AudioRecThread.encodeContinue="+audioRecContinue
                    // ) ;
                    try {
                        int read = audioRecord.read(bufRead, 0,
                                bufReadLenInByte);
                        if (read > 0) {
                            fo.write((byte[]) bufRead, 0, read);
                            datalength += read;
                        }
                    } catch (IOException e) {

                    }
                }
                try {
                    fo.seek(4);
                    writeInt(fo, 36 + datalength);
                    fo.seek(40);
                    writeInt(fo, datalength);
                    fo.close();
                } catch (IOException e) {

                }
                try {
                    audioRecord.stop();
                } catch (IllegalStateException e) {

                }
                audioRecord.release();

                wl.release();
                handler.sendEmptyMessage(MSG_AUDIO_REC_FINISH);
                Log.v(TAG, "AvcThread Finish encoding ");
            }
        };
        startLowPriorityNewThread(audioRecRun);
    }

    public void stopAudioRec() {
        audioRecContinue = false;
        if (thread != null) {
            try {
                thread.join();
            } catch (InterruptedException e) {

            }
        }

        thread = null;
        // Log.v(TAG,"in stopAvcEnc AvcThread.encodeContinue="+encodeContinue )
        // ;
    }

    private short readShort(FileInputStream fi) throws IOException {
        byte tmp[] = { 0, 0 };
        try {
            fi.read(tmp);
        } catch (IOException e) {
            throw e;
        }
        short r = tmp[1];
        r <<= 8;
        r += tmp[0];
        return r;
    }

    private int readInt(FileInputStream fi) throws IOException {
        byte tmp[] = { 0, 0, 0, 0 };

        try {
            fi.read(tmp);
        } catch (IOException e) {
            throw e;
        }
        int r = tmp[3];
        r <<= 8;
        r += tmp[2];
        r <<= 8;
        r += tmp[1];
        r <<= 8;
        r += tmp[0];

        return r;
    }

    void startAudioPlay(final String audioFname, final Handler handler) {

        final Runnable audioRecRun = new Runnable() {
            public void run() {
                FileInputStream fi;
                try {
                    fi = new FileInputStream(audioFname);
                } catch (FileNotFoundException e) {
                    e.printStackTrace();
                    return;
                }

                short channels = 1;
                int blockAlign;
                int bitsPerSample;
                int sampleRate;

                wl.acquire();

                int datalength = 0;

                try {
                    byte[] tmp = { 0, 0, 0, 0 };
                    fi.read(tmp);
                    boolean check = Arrays.equals(tmp, "RIFF".getBytes());
                    if (check != true)
                        return;
                    fi.read(tmp); // Riff file length
                    fi.read(tmp);
                    check = Arrays.equals(tmp, "WAVE".getBytes()); // 4
                    if (check != true)
                        return;
                    fi.read(tmp);
                    check = Arrays.equals(tmp, "fmt ".getBytes()); // 4
                    if (check != true)
                        return;
                    int headlen = readInt(fi);
                    if (headlen != 16)
                        return; // 4 , followed by 16 bytes
                    short s = readShort(fi);
                    if (s != 1)
                        return;// pcm wave tag
                    channels = readShort(fi);
                    sampleRate = readInt(fi);
                    readInt(fi); // bitsPerSample*sampleRate*channels/8) ;
                    blockAlign = readShort(fi);// ,
                                                // (short)(channels*bitsPerSample/8)
                                                // ) ;
                    bitsPerSample = readShort(fi);// ,(short)bitsPerSample) ;
                    fi.read(tmp); // "data"); // 4
                    fi.read(tmp); // 4 ,data length
                } catch (IOException e) {
                    return;
                }

                int format;// = AudioFormat.ENCODING_PCM_16BIT ;
                int channel;// =AudioFormat.CHANNEL_CONFIGURATION_MONO ;

                if (channels == 2)
                    channel = AudioFormat.CHANNEL_OUT_STEREO;
                else if (channels == 1)
                    channel = AudioFormat.CHANNEL_OUT_MONO;
                else
                    channel = -1;

                if (bitsPerSample == 16)
                    format = AudioFormat.ENCODING_PCM_16BIT;
                else if (bitsPerSample == 8)
                    format = AudioFormat.ENCODING_PCM_8BIT;
                else
                    format = -1;

                int bufferSizeInBytes = AudioTrack.getMinBufferSize(sampleRate,
                        channel, format) * 4;
                if (bufferSizeInBytes < channels * bitsPerSample * 2 / 8
                        * sampleRate)
                    ;
                bufferSizeInBytes = channels * bitsPerSample * 2 / 8
                        * sampleRate;
                Log.v(TAG + " write", "bufferSizeInBytes=" + bufferSizeInBytes);

                AudioTrack audioTrack = new AudioTrack(
                        AudioManager.STREAM_MUSIC, sampleRate, channel, format,
                        bufferSizeInBytes, AudioTrack.MODE_STREAM);
                if (audioTrack == null)
                    return;
                int bufReadLenInByte = bufferSizeInBytes / 8;
                byte[] bufRead = new byte[bufReadLenInByte];
                audioPlayContinue = true;

                audioTrack.setPositionNotificationPeriod(200);

                markPos = sampleRate * markMill / 1000;
                int rr = audioTrack.setNotificationMarkerPosition(markPos);
                Log.v(TAG + " Period currpos",
                        "setNotificationMarkerPosition return " + rr);
                audioTrack
                        .setPlaybackPositionUpdateListener(AudioRecThread.this);
                // int rr = audioTrack.setPlaybackHeadPosition(8000*5);
                // Log.v(TAG+" Period", "setPlaybackHeadPosition return "+rr) ;
                startPlayMilli = System.currentTimeMillis();
                Log.v(TAG + " Period currpos", "startPlayMilli= "
                        + startPlayMilli);
                playUpdatePeriodAmass = 0;
                rr = audioTrack.getPlaybackHeadPosition();
                Log.v(TAG + " Period", "getPlaybackHeadPosition return " + rr);

                while (audioPlayContinue) {
                    // Log.v(TAG+"-ENC","In run AudioRecThread.encodeContinue="+audioRecContinue
                    // ) ;
                    try {
                        int read = fi.read(bufRead, 0, bufReadLenInByte);
                        if (read > 0) {
                            Log.v(TAG + " write", "before write to AudioTrack");
                            read = audioTrack.write((byte[]) bufRead, 0, read);
                            Log.v(TAG + " write",
                                    "after write to AudioTrack, write " + read
                                            + " bytes");
                            if (datalength == 0) {
                                try {
                                    Log.v(TAG + " Period currpos",
                                            "startPlay : "
                                                    + System.currentTimeMillis());
                                    audioTrack.play();
                                    bufReadLenInByte /= 10;
                                } catch (IllegalStateException e) {

                                }
                            }
                            datalength += read;
                        } else {
                            break;
                        }
                    } catch (IOException e) {

                    }

                    long cu = System.currentTimeMillis();
                    long cu1 = cu - startPlayMilli;
                    long cu2 = cu - timeMarkAttendModified;
                    rr = audioTrack.getPlaybackHeadPosition();
                    Log.v(TAG + " Period currpos", "curr: " + cu1
                            + " modified mill:" + cu2 + " pos:" + rr * 1000
                            / 8000);

                }
                try {
                    fi.close();
                } catch (IOException e) {

                }
                ;
                try {
                    Log.v(TAG + " Period", "dataLength=" + datalength);
                    audioTrack.flush();
                    // for (int i = 50; i > 0; i--) {
                    // long cu = System.currentTimeMillis();
                    // long cu1 = cu - startPlayMilli;
                    // long cu2 = cu - timeMarkAttendModified;
                    // rr = audioTrack.getPlaybackHeadPosition();
                    // Log.v(TAG + " Period currpos", "curr: " + cu1
                    // + " modified mill:" + cu2 + " pos:" + rr * 1000
                    // / 8000);
                    //
                    // Thread.sleep(100);
                    // }
                    audioTrack.stop();
                } catch (Exception e) {
                    e.printStackTrace();
                }/*
                 * catch (InterruptedException e) {
                 * 
                 * }
                 */
                audioTrack.release();

                wl.release();
                handler.sendEmptyMessage(MSG_AUDIO_PLAY_FINISH);
                Log.v(TAG, "AvcThread Finish encoding ");
            }
        };
        startLowPriorityNewThread(audioRecRun);
    }

    public void stopAudioPlay() {
        audioPlayContinue = false;
        if (thread != null) {
            try {
                thread.join();
            } catch (InterruptedException e) {

            }
        }

        thread = null;
        // Log.v(TAG,"in stopAvcEnc AvcThread.encodeContinue="+encodeContinue )
        // ;
    }

    private void startLowPriorityNewThread(Runnable run) {
        thread = new Thread(run);
        int pr = thread.getPriority();
        Log.v(TAG, "Original Thread priority is " + pr);
        thread.setPriority(pr - 1);
        pr = thread.getPriority();
        Log.v(TAG, "new Thread priority is " + pr);
        thread.start();
    }

}

其中wav和pcm的区别
audiotrack只能播放pcm的数据,

如果测试单独模块,可以单独挑出其中的代码进行测试,其中randomAssessFile的seek方法每次都是针对文件头算的.
其中遇到的几个问题:
java.lang.IllegalStateException: startRecording() called on an uninitialized AudioRecord.
原因:

1.没有增加权限
    <!-- 录音权限 -->  
    <uses-permission android:name="android.permission.RECORD_AUDIO" />
2.参数错误
//这里使用MediaRecorder.AudioSource.DEFAULT就好
audioRecThread.startAudioRec(path,MediaRecorder.AudioSource.DEFAULT, new Handler(getMainLooper()){
                    @Override
                    public void handleMessage(Message msg) {
                        super.handleMessage(msg);
                        Toast.makeText(getApplicationContext(), "完毕", 0).show();
                    }
                });
                //有些设备的采样率不支持8k,导致初始化出现问题,这里改为16k就好了
AudioRecord audioRecord = new AudioRecord(audioSource,
                        sampleRate, channel, format, bufferSizeInBytes);
3.回调onPeriodicNotification发生异常
10-12 13:29:46.017: E/AndroidRuntime(5549): java.lang.IllegalStateException: Unable to retrieve AudioTrack pointer for getPosition()
10-12 13:29:46.017: E/AndroidRuntime(5549):     at android.media.AudioTrack.native_get_position(Native Method)
10-12 13:29:46.017: E/AndroidRuntime(5549):     at android.media.AudioTrack.getPlaybackHeadPosition(AudioTrack.java:642)
10-12 13:29:46.017: E/AndroidRuntime(5549):     at com.txz.test.AudioRecThread.onPeriodicNotification(AudioRecThread.java:42)
10-12 13:29:46.017: E/AndroidRuntime(5549):     at android.media.AudioTrack$NativeEventHandlerDelegate$1.handleMessage(AudioTrack.java:1273)
10-12 13:29:46.017: E/AndroidRuntime(5549):     at android.os.Handler.dispatchMessage(Handler.java:102)
10-12 13:29:46.017: E/AndroidRuntime(5549):     at android.os.Looper.loop(Looper.java:136)
10-12 13:29:46.017: E/AndroidRuntime(5549):     at android.app.ActivityThread.main(ActivityThread.java:5017)
10-12 13:29:46.017: E/AndroidRuntime(5549):     at java.lang.reflect.Method.invokeNative(Native Method)
10-12 13:29:46.017: E/AndroidRuntime(5549):     at java.lang.reflect.Method.invoke(Method.java:515)
10-12 13:29:46.017: E/AndroidRuntime(5549):     at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:779)
10-12 13:29:46.017: E/AndroidRuntime(5549):     at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:595)
10-12 13:29:46.017: E/AndroidRuntime(5549):     at dalvik.system.NativeStart.main(Native Method)

解决办法:

    public void onPeriodicNotification(AudioTrack track) {
        if (track.getState()==AudioTrack.PLAYSTATE_PLAYING) {//增加状态判断
            playUpdatePeriodAmass += 25;
            long c = System.currentTimeMillis();
            c -= startPlayMilli;
            c = track.getPlaybackHeadPosition();
            c /= 8;
            Log.v(TAG + " onPeriodicNotification", "real ms " + c
                    + " period total " + playUpdatePeriodAmass);
        }
    }
晴空一垩
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AudioRecord实现实时录音和MediaCode转码
wangxiuwen12的博客
09-19 1429
           最近在做一个基于海思芯片网络摄像头的项目，其中有个需求就是能够实时通话，就和语音聊天一样，但是只要实现一边的实时传输功能就可以了，于是花了接近两个星期的捣鼓，终于搞出了一个比较完美的方案（原谅自己的菜）     AudioRecord 简介       Android提供了两个函数可以实现录音功能，一个是AudioRecord,另一个是功能比较强大的MediaRecor...
AudioTrack和RTP 和 Socket
04-15
理解AudioTrack的工作原理和使用方法对于开发音频应用至关重要。 首先，AudioTrack的创建需要提供一些基本参数，如音频格式（例如AAC、MP3或PCM）、通道配置（单声道或立体声）、采样率（例如44100Hz）以及缓冲区...
audiotrack播放PCM音频数据的例子
12-26
一个使用audiotrack播放PCM音频数据的DEMO，上传的代码工程中有个音频数据文件夹，包含了用于测试的PCM数据文件，详情请看readme.txt;另外代码附详细说明，走过路过的都不要错过了，喜欢就顶下吧
Android Audio代码分析1 - AudioTrack使用示例
weixin_33829657的博客
09-29 246
计划从接口的使用，开始分析Audio相关源码。 此处的代码为Android中自带的测试代码。 由于本人惰性，不打算将所有函数全部细说。主要函数，会拿来细细品味；本人认为非主要的函数，将一笔带过。 主要非主要，是从本人当前项目的需要来看的。 *****************************************源码*****************************...
Android Audio——使用 AudioTrack 播放音频
最新发布
liuning1985622的博客
05-02 1764
Android SDK 提供了3套音频播放的API，分别是：MediaPlayer，SoundPool，AudioTrack。简单来说，MediaPlayer 更加适合在后台长时间播放本地音乐文件或者在线的流式资源;SoundPool 则适合播放比较短的音频片段，比如游戏声音、按键声、铃声片段等等，它可以同时播放多个音频;而 AudioTrack 则更接近底层，提供了非常强大的控制能力，支持低延迟播放，适合流媒体和VoIP 语音电话等场景。
音频采集（AudioRecorder）
u010029439的博客
12-18 7220
https://www.jianshu.com/p/125b94af7c08   音频采集（AudioRecorder） 安仔夏天勤奋 2018.05.08 21:50* 字数 1426 阅读 2134评论 0喜欢 2 音频采集 想更好地了解音频采集，首先要去了解一些音频入门基础知识。关于一些音频开发的一些基础知识，这里就不一一讲解了，可以去了解Android音频技术开发的一些基础...
AudioTrack 使用
朝花夕拾
04-03 1527
一、AuidoTrack 使用步骤 1、获取最小缓存区大小 使用 AudioTrack 的静态成员，获取音频缓存区最小尺寸： static public int getMinBufferSize(int sampleRateInHz, int channelConfig, int audioFormat) sampleRateInHz：音频采用率，常用的采样率有 8k、16k、44.1K、48k。 channelConfig：声道配置，常用配置有 CHANNEL_IN_MONO (单声道)、CHANNEL
AudioRecord和AudioTrack
01-27
在Android平台上，AudioRecord和AudioTrack是两个非常重要的音频处理类，它们分别用于音频的录制和播放。在本文中，我们将深入探讨这两个类的工作原理、使用方法以及如何结合它们实现一个简单的音频处理流程。 首先...
音频录制和播放示例
05-07
本示例“音频录制和播放示例”提供了一个基础的实现方式，利用了Android SDK中的AudioRecord和AudioTrack类。下面我们将深入探讨这两个核心组件以及它们在音频处理中的作用。 AudioRecord是Android提供的一个API，...
Audiotrack
09-27
为了提高性能，可以使用缓冲区管理来减少`write()`调用的频率，或者使用硬件加速功能，如`AudioTrack`的`setAudioAttributes()`方法来指定`AudioAttributes`，选择合适的音频流类型和内容类型。 8. **示例代码** ...
Android AudioRecord 和 AudioTrack 使用例程
09-26
AudioRecord和AudioTrack是Android SDK提供的两个核心类，分别用于音频输入和输出。本示例程序旨在帮助开发者深入理解这两个类的用法，以便在自己的应用中实现高质量的音频功能。 AudioRecord类是用于从设备麦克风...
TinyAlsa 之举从驱动拿到指定设备的音频输入，同时 AudioTrack 和 AudioRecode 使用默认输入输出
04-28
自己写的一个DEMO，以便以后用到，有兴趣的也可以一起研究：：：：TinyAlsa 之举从驱动拿到指定设备的音频输入，同时 AudioTrack 和 AudioRecode 使用默认输入输出 ,中间还有命令工具
AudioTrack_socket.zip
12-23
本示例针对Android 9.0（Pie）系统，展示了如何使用AudioTrack结合Socket通信来接收并播放通过TCP协议从服务器端传输的音频裸数据。 首先，`AudioController.java`很可能是整个音频播放系统的控制器，它负责初始化...
AudioTrack.svg
06-12
AudioTrack.svg UML顺序图
AudioRecord和AudioTrack实现录音和播放
05-28
在`AudioRecordPlay`这个项目中，可能包含了实现这种同步机制的代码示例，以及如何设置和使用AudioRecord和AudioTrack的详细步骤。通过学习和分析这个项目，开发者可以更好地理解和掌握Android音频处理的核心技术，...
Android音频系统AudioTrack使用方法详解
08-29
Android音频系统AudioTrack使用方法详解 Android音频系统中，...AudioTrack是Android音频系统中播放音频的重要组件，了解AudioTrack的使用方法和工作原理，可以帮助开发者更好地使用AudioTrack进行音频播放。
2016年12月9日工作总结（JNI问题，AudioTrack之回调，FFmpeg之Seek）
telenewbie的专栏
12-09 961
1.这个是今天定位系统Selector.select(long timeout)和select()一样，除了最长会阻塞timeout毫秒(参数)。 没有用处，顾用sleep来替换 Java NIO 系列教程 2.在解码的时候没有调用 avcodec_flush_buffers(pFormatCtx->streams[videoStream]->codec); 导致seek播放的问题 FFmp
java audiotrack_java – 如何告诉AudioTrack对象何时完成播放？
weixin_35327612的博客
02-13 422
我发现使用audioTrack.setNotificationMarkerPosition(audioLength)和audioTrack.setPlaybackPositionUpdateListener对我有用.请参阅以下代码：// Get the length of the audio stored in the file (16 bit so 2 bytes per short)// an...
Android深入浅出之Audio 第一部分 AudioTrack分析
android_lee的专栏
07-04 2446
Android深入浅出之Audio第一部分 AudioTrack分析一目的本文的目的是通过从Audio系统来分析Android的代码，包括Android自定义的那套机制和一些常见类的使用，比如Thread，MemoryBase等。分析的流程是：l
怎么结合audioRecord和audioTrack
04-26
要实现基于Android平台的录音和播放功能，可以结合使用AudioRecord和AudioTrack，具体步骤如下： 1.创建AudioRecord对象，设置录音参数，如采样率、声道数和采样位深等。可以使用MediaRecorder.AudioSource.MIC设置...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值