Android 采集音频与音频解码

最新推荐文章于 2024-05-15 09:22:17 发布
最新推荐文章于 2024-05-15 09:22:17 发布
阅读量880 收藏 1
点赞数 1
分类专栏： ffmpeg Android开发 文章标签： ffmpeg android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_15255121/article/details/117791838
版权

使用AudioRecord采集音频pcm数据，使用MediaCodec转化为aac数据

package com.yuanxuzhen.yuanrecord;

import android.content.Context;
import android.media.AudioFormat;
import android.media.AudioRecord;
import android.media.MediaRecorder;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class RecordAudio {
    private int mSampleRate = 44100;
    private int mInChannel = AudioFormat.CHANNEL_IN_STEREO;
    private int mSampleFormat = AudioFormat.ENCODING_PCM_16BIT;

    public int getmChannelCount() {
        return mChannelCount;
    }

    private int mChannelCount = 2;
    private String mFilePath = null;
    private AudioRecord mRecorder = null;
    ExecutorService mExecutorService;
    private int mBufferSize;

    public enum AUDIO_STAUS {
        START,
        PAUSE,
        STOP
    }
    AUDIO_STAUS mStatus;
    public void init(Context context, int sampleRate, int inChannel, int sampleFormat, String filePath) {
        mSampleRate = sampleRate;
        mInChannel = inChannel;
        mSampleFormat = sampleFormat;
        mFilePath = filePath;
        mBufferSize = AudioRecord.getMinBufferSize(mSampleRate,
                mInChannel, mSampleFormat);
        mRecorder = new AudioRecord(MediaRecorder.AudioSource.MIC,
                mSampleRate, mInChannel,
                mSampleFormat,
                mBufferSize);
        mChannelCount = mRecorder.getChannelCount();
        mExecutorService = Executors.newCachedThreadPool();
    }


    public void startRecord() {
        if(mStatus == AUDIO_STAUS.START){
            return;
        }
        if(mStatus == AUDIO_STAUS.STOP){
            File file = new File(mFilePath);
            if(file.exists()){
                file.delete();
            }
        }
        mStatus = AUDIO_STAUS.START;
        mRecorder.startRecording();
        mExecutorService.execute(new Runnable() {
            @Override
            public void run() {
                realStartRecord();
            }
        });
    }

    private void realStartRecord() {
        // Write the output audio in byte
        short sData[] = new short[mBufferSize / 2];
        byte  byteData[] = new byte[mBufferSize];

        FileOutputStream os = null;
        try {
            os = new FileOutputStream(mFilePath, true);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }

        while (mStatus == AUDIO_STAUS.START) {
            // gets the voice output from microphone to byte format
            if(mSampleFormat == AudioFormat.ENCODING_PCM_16BIT){
                int size = mRecorder.read(sData, 0, mBufferSize / 2);
                System.out.println("Short wirting to file size=" + size);
                try {
                    // // writes the data to file from buffer
                    // // stores the voice buffer
                    byte bData[] = short2byte(sData);
                    os.write(bData, 0, mBufferSize);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }else{
                int size = mRecorder.read(byteData, 0, mBufferSize);
                System.out.println("Short wirting to file size=" + size);
                try {
                    // // writes the data to file from buffer
                    // // stores the voice buffer
                    os.write(byteData, 0, mBufferSize);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }
        try {
            os.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //convert short to byte
    private byte[] short2byte(short[] sData) {
        int shortArrsize = sData.length;
        byte[] bytes = new byte[shortArrsize * 2];
        for (int i = 0; i < shortArrsize; i++) {
            bytes[i * 2] = (byte) (sData[i] & 0x00FF);
            bytes[(i * 2) + 1] = (byte) (sData[i] >> 8);
            sData[i] = 0;
        }
        return bytes;

    }


    public void pauseRecord(){
        mStatus = AUDIO_STAUS.PAUSE;
        if(mRecorder != null)
            mRecorder.stop();

    }

    public void stopRecord(){
        mStatus = AUDIO_STAUS.STOP;
        if(mRecorder != null)
            mRecorder.stop();
        release();
    }

    public void release(){
        if(mRecorder == null){
            return;
        }
        mRecorder.release();
        mRecorder = null;
    }


}

 

下面是aac编码的操作，难点在于从pcm文件每次都少数据给编码器。如果听到的声音不对，就调整这个参数。 byte[] byteArray = new byte[2048];我这里设置了2048.在ffmpeg中，这个参数来自于编码器（ffmpeg计算方法是size= nb_sample * channel * bytePerSample）.

package com.yuanxuzhen.yuanrecord;

import android.content.Context;
import android.media.AudioFormat;
import android.media.AudioRecord;
import android.media.MediaCodec;
import android.media.MediaCodecInfo;
import android.media.MediaFormat;
import android.media.MediaRecorder;
import android.os.Build;
import android.util.Log;

import androidx.annotation.RequiresApi;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class EncodeAudioAAC {
    private int mSampleRate = 44100;
    private int mInChannel = AudioFormat.CHANNEL_IN_STEREO;
    private int mSampleFormat = AudioFormat.ENCODING_PCM_16BIT;
    private int mChannelCount = 2;
    private String mDstFilePath = null;
    private String mSrcFilePath = null;
    MediaCodec mEncorder;
    ExecutorService mExecutorService;
    private int mBufferSize;
    private IHandlerCallback mCallback;


    public void init(Context context, int sampleRate,
                     int channelCount, int sampleFormat,
                     String srcPath, String dstPath,
                     IHandlerCallback callback) {
        mSampleRate = sampleRate;
        mChannelCount = channelCount;
        mSampleFormat = sampleFormat;
        mSrcFilePath = srcPath;
        mDstFilePath = dstPath;
        mExecutorService = Executors.newCachedThreadPool();
        mCallback = callback;
        mBufferSize = AudioRecord.getMinBufferSize(mSampleRate,
                mInChannel, mSampleFormat);
        try {
            mEncorder = MediaCodec.createEncoderByType(MediaFormat.MIMETYPE_AUDIO_AAC);
        } catch (Exception e) {
            e.printStackTrace();
        }
        MediaFormat format = MediaFormat.createAudioFormat(MediaFormat.MIMETYPE_AUDIO_AAC,
                mSampleRate,
                mChannelCount);
        format.setString(MediaFormat.KEY_MIME, MediaFormat.MIMETYPE_AUDIO_AAC);
        format.setInteger(MediaFormat.KEY_AAC_PROFILE, MediaCodecInfo.CodecProfileLevel.AACObjectLC);
        format.setInteger(MediaFormat.KEY_BIT_RATE, 100000);
        format.setInteger(MediaFormat.KEY_MAX_INPUT_SIZE, mBufferSize);
        mEncorder.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
    }


    /**
     * 开始编码
     */
    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
    public void startEncording() {
        if (mEncorder == null) {
            if(mCallback != null){
                mCallback.onFail();
            }
            return;
        }
        mEncorder.start();
        try {
            FileInputStream inputStream = new FileInputStream(mSrcFilePath);
            FileOutputStream mFileStream = new FileOutputStream(mDstFilePath);
            MediaCodec.BufferInfo mBufferInfo = new MediaCodec.BufferInfo();
            while(true) {
                long a = System.currentTimeMillis();
                // 从队列中取出录音的一帧音频数据
                byte[] byteArray = new byte[2048];
                int readSize = inputStream.read(byteArray);
                if(readSize <= 0){
                    break;
                }
                ByteBuffer buf = ByteBuffer.wrap(byteArray);
                // 取出InputBuffer，填充音频数据，然后输送到编码器进行编码
                int inputBufferIndex = mEncorder.dequeueInputBuffer(0);
                if (inputBufferIndex >= 0) {
                    ByteBuffer inputBuffer = mEncorder.getInputBuffer(inputBufferIndex);
                    inputBuffer.clear();
                    inputBuffer.put(buf);
                    mEncorder.queueInputBuffer(inputBufferIndex, 0, readSize, System.nanoTime(), 0);
                }

                // 取出编码好的一帧音频数据，然后给这一帧添加ADTS头
                int outputBufferIndex = mEncorder.dequeueOutputBuffer(mBufferInfo, 0);
                while (outputBufferIndex >= 0) {
                    ByteBuffer outputBuffer = mEncorder.getOutputBuffer(outputBufferIndex);
                    int outBufferSize = outputBuffer.limit() + 7;
                    byte[] aacBytes = new byte[outBufferSize];
                    addADTStoPacket(aacBytes, outBufferSize);
                    outputBuffer.get(aacBytes, 7, outputBuffer.limit());
                    mFileStream.write(aacBytes);

                    mEncorder.releaseOutputBuffer(outputBufferIndex, false);
                    outputBufferIndex = mEncorder.dequeueOutputBuffer(mBufferInfo, 0);
                }

                long b = System.currentTimeMillis() - a;
                Log.i("AudioEncode", "编码耗时-毫秒==" + b);
            }
            if (mFileStream != null) {
                try {
                    mFileStream.flush();
                    mFileStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if (inputStream != null) {
                try {
                    mFileStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (mEncorder != null) {
                mEncorder.stop();
            }
            if(mCallback != null){
                mCallback.onSuccess();
            }
        } catch (FileNotFoundException e) {
            if(mCallback != null){
                mCallback.onFail();
            }
            e.printStackTrace();
        } catch (IOException e) {
            if(mCallback != null){
                mCallback.onFail();
            }
            e.printStackTrace();
        }
    }





    /**
     * Add ADTS header at the beginning of each and every AAC packet.
     * This is needed as MediaCodec encoder generates a packet of raw
     * AAC data.
     * <p>
     * Note the packetLen must count in the ADTS header itself !!! .
     * 注意，这里的packetLen参数为raw aac Packet Len + 7; 7 bytes adts header
     **/
    private void addADTStoPacket(byte[] packet, int packetLen) {
        int profile = 2;  //AAC LC，MediaCodecInfo.CodecProfileLevel.AACObjectLC;
        int freqIdx = 4;  //见后面注释avpriv_mpeg4audio_sample_rates中32000对应的数组下标，来自ffmpeg源码
        int chanCfg = 1;  //见后面注释channel_configuration，AudioFormat.CHANNEL_IN_MONO 单声道(声道数量)

        /*int avpriv_mpeg4audio_sample_rates[] = {96000, 88200, 64000, 48000, 44100, 32000,24000, 22050, 16000, 12000, 11025, 8000, 7350};
        channel_configuration: 表示声道数chanCfg
        0: Defined in AOT Specifc Config
        1: 1 channel: front-center
        2: 2 channels: front-left, front-right
        3: 3 channels: front-center, front-left, front-right
        4: 4 channels: front-center, front-left, front-right, back-center
        5: 5 channels: front-center, front-left, front-right, back-left, back-right
        6: 6 channels: front-center, front-left, front-right, back-left, back-right, LFE-channel
        7: 8 channels: front-center, front-left, front-right, side-left, side-right, back-left, back-right, LFE-channel
        8-15: Reserved
        */

        // fill in ADTS data
        packet[0] = (byte) 0xFF;
        //packet[1] = (byte)0xF9;
        packet[1] = (byte) 0xF1;//解决ios 不能播放问题
        packet[2] = (byte) (((profile - 1) << 6) + (freqIdx << 2) + (chanCfg >> 2));
        packet[3] = (byte) (((chanCfg & 3) << 6) + (packetLen >> 11));
        packet[4] = (byte) ((packetLen & 0x7FF) >> 3);
        packet[5] = (byte) (((packetLen & 7) << 5) + 0x1F);
        packet[6] = (byte) 0xFC;
    }

    public void release(){
        if(mEncorder == null){
            return;
        }
        mEncorder.release();
        mEncorder = null;
    }
}

 

package com.yuanxuzhen.yuanrecord;

import android.content.Context;
import android.os.Environment;

import java.io.File;

public class DirUtil {
    public static final String WEBVIEW_CACHE = ".webviewCache";
    public static final String IMAGE_PATH = "image";
    public static final String DOWNLOAD_PATH = "download";
    public static final String VIDEO_PATH = ".video";
    public static final String NET_PATH = ".net";


    //image
    public static String getImageDir(Context context) {
        return getCacheDir(context) + File.separator + IMAGE_PATH;
    }

    //webview
    public static String getWebviewCache(Context context) {
        return getCacheDir(context) + File.separator + WEBVIEW_CACHE;
    }

    //download
    public static String getDownloadDir(Context context) {
        return getCacheDir(context) + File.separator + DOWNLOAD_PATH;
    }

    //video
    public static String getVideoPath(Context context) {
        return getCacheDir(context) + File.separator + VIDEO_PATH;
    }

    //net
    public static String getNetPath(Context context) {
        return getCacheDir(context) + File.separator + NET_PATH;
    }


    public static String getCacheDir(Context context) {
        if (context == null) {
            return "";
        }
        String path = null;
        if (context.getExternalCacheDir() != null
                && (Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState())
                || !Environment.isExternalStorageRemovable())) {
            //外部存储可用
            path = context.getExternalCacheDir().getPath();
        } else {
            //内部存储不可用
            path = context.getCacheDir().getPath();
        }
        return path;
    }




}

 

package com.yuanxuzhen.yuanrecord;

public interface IHandlerCallback {
    void onSuccess(Object... object);

    void onFail(Object... object);
}

 

调用

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity"
    android:orientation="vertical"
    android:paddingTop="100dp">


    <Button
        android:id="@+id/btnStart"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="start!"
        android:layout_gravity="center_horizontal"/>

    <Button
        android:id="@+id/btnPause"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="pause!"
        android:layout_gravity="center_horizontal"/>

    <Button
        android:id="@+id/btnStop"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="stop!"
        android:layout_gravity="center_horizontal"/>

    <Button
        android:id="@+id/encode_aac"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="encode pcm to aac "
        android:layout_gravity="center_horizontal"/>


</LinearLayout>
package com.yuanxuzhen.yuanrecord;

import android.app.Activity;
import android.media.AudioFormat;
import android.os.Build;
import android.os.Bundle;
import android.view.KeyEvent;
import android.view.View;
import android.widget.Button;
import android.widget.Toast;
import androidx.annotation.RequiresApi;
import java.io.File;



public class Audio_Record extends Activity {
    private static final int RECORDER_SAMPLERATE = 44100;
    private static final int RECORDER_CHANNELS = AudioFormat.CHANNEL_IN_STEREO;
    private static final int RECORDER_AUDIO_ENCODING = AudioFormat.ENCODING_PCM_16BIT;
    private RecordAudio mRecorder;
    private EncodeAudioAAC mEncoder;
    private String pcmPath;
    private String aacPath;
    private Button btnStart;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_record);

        setButtonHandlers();
        btnStart = findViewById(R.id.btnStart);
        enableButton(R.id.btnStart, true);
        enableButton(R.id.btnPause, false);
        enableButton(R.id.btnStop, false);
        pcmPath = DirUtil.getCacheDir(this) + File.separator + "123.pcm";
        aacPath = DirUtil.getCacheDir(this) + File.separator + "123.aac";

        mRecorder = new RecordAudio();
        mRecorder.init(this, RECORDER_SAMPLERATE, RECORDER_CHANNELS, RECORDER_AUDIO_ENCODING, pcmPath);

        mEncoder = new EncodeAudioAAC();
        mEncoder.init(this,
                RECORDER_SAMPLERATE,
                mRecorder.getmChannelCount(),
                RECORDER_AUDIO_ENCODING,
                pcmPath,
                aacPath,
                new IHandlerCallback() {
                    @Override
                    public void onSuccess(Object... object) {
                        btnStart.post(new Runnable() {
                            @Override
                            public void run() {
                                Toast.makeText(Audio_Record.this, "解码成功", Toast.LENGTH_SHORT).show();
                            }
                        });
                    }

                    @Override
                    public void onFail(Object... object) {
                        btnStart.post(new Runnable() {
                            @Override
                            public void run() {
                                Toast.makeText(Audio_Record.this, "解码失败", Toast.LENGTH_SHORT).show();
                            }
                        });
                    }
                });
    }

    private void setButtonHandlers() {
        ((Button) findViewById(R.id.btnStart)).setOnClickListener(btnClick);
        ((Button) findViewById(R.id.btnStop)).setOnClickListener(btnClick);
        ((Button) findViewById(R.id.btnPause)).setOnClickListener(btnClick);
        ((Button) findViewById(R.id.encode_aac)).setOnClickListener(btnClick);

    }

    private void enableButton(int id, boolean isEnable) {
        ((Button) findViewById(id)).setEnabled(isEnable);
    }


    private void enableButtons(RecordAudio.AUDIO_STAUS status) {
        if (status == RecordAudio.AUDIO_STAUS.START) {
            enableButton(R.id.btnStart, false);
            enableButton(R.id.btnPause, true);
            enableButton(R.id.btnStop, true);
        } else if (status == RecordAudio.AUDIO_STAUS.PAUSE) {
            enableButton(R.id.btnStart, true);
            enableButton(R.id.btnPause, false);
            enableButton(R.id.btnStop, true);
        } else if (status == RecordAudio.AUDIO_STAUS.STOP) {
            enableButton(R.id.btnStart, true);
            enableButton(R.id.btnPause, false);
            enableButton(R.id.btnStop, false);
        }

    }


    private View.OnClickListener btnClick = new View.OnClickListener() {
        @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
        public void onClick(View v) {
            switch (v.getId()) {
                case R.id.btnStart: {
                    Toast.makeText(Audio_Record.this, "开始录制", Toast.LENGTH_SHORT).show();
                    mRecorder.startRecord();
                    enableButtons(mRecorder.mStatus);
                    break;
                }
                case R.id.btnPause: {
                    Toast.makeText(Audio_Record.this, "暂停录制", Toast.LENGTH_SHORT).show();
                    mRecorder.pauseRecord();
                    enableButtons(mRecorder.mStatus);
                    break;
                }
                case R.id.btnStop: {
                    Toast.makeText(Audio_Record.this, "停止录制", Toast.LENGTH_SHORT).show();
                    mRecorder.stopRecord();
                    enableButtons(mRecorder.mStatus);
                    break;
                }
                case R.id.encode_aac: {
                    Toast.makeText(Audio_Record.this, "开始转码", Toast.LENGTH_SHORT).show();
                    mEncoder.startEncording();
                    break;
                }
            }
        }
    };

    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        if (keyCode == KeyEvent.KEYCODE_BACK) {
            finish();
        }
        return super.onKeyDown(keyCode, event);
    }

    @Override
    protected void onDestroy() {
        mRecorder.release();
        mEncoder.release();
        super.onDestroy();
    }
}

 

原总破局
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
MediaCodec进行编解码AAC（文件格式转换）
欢迎关注公众号：【码农突围】，回复9999，可以获取一份LeetCode刷题笔记
01-18 2174
本文来自eric原创授权发布，eric，音视频开发爱好者，简书地址：https://www.jianshu.com/u/1502591a1753。欢迎大家关注。AAC，全称Advanced Audio Coding，是一种专为声音数据设计的文件压缩格式。与MP3不同，它采用了全新的算法进行编码，更加高效，具有更高的“性价比”。利用AAC格式，可使人感觉声音质量没有明显降低的前提下，更加小巧。在介绍
MediaRecorder录制
eatlemon的博客
09-16 1450
MediaRecorder录制流程ing ing
一文搞懂 Android 音视频编解码器 MediaCodec
最新发布
weixin_46056189的博客
05-15 2177
一文搞懂 Android 音视频编解码器 MediaCodec，介绍了MediaCodec的流程和基本用法。
音视频入门之音频采集、编码、播放
weixin_33749242的博客
09-06 3362
本文由玉刚说写作平台提供写作赞助，版权归玉刚说微信公众号所有原作者：苍溟版权声明：未经玉刚说许可，不得以任何形式转载 今天我们学习音频的采集、编码、生成文件、转码等操作，我们生成三种格式的文件格式，pcm、wav、aac 三种格式，并且我们用 AudioStack 来播放音频，最后我们播放这个音频。 本篇文章你将学到: AudioRecord 音频的采集 生成 PCM 文件 PCM 转化...
Android MIME类型
pengjianbosoft的专栏
07-29 1370
一、MIME TYPE描述 多用途互联网邮件扩展（MIME，Multipurpose Internet Mail Extensions）是一个互联网标准，它扩展了电子邮件标准，使其能够支持非ASCII字符、二进制格式附件等多种格式的邮件消息。 内容类型（Content
音视频开发：MediaCodec录制MP4文件
m0_60259116的博客
08-27 1680
音视频开发：MediaCodec录制MP4文件
安卓mediaformat api详解
09-15 9978
MediaFormat 重申一下，此翻译直接使用浏览器翻译的，目的只在于看一下有哪些方法，方法是什么含义。 扩展对象 java.lang.Object继承    ↳ android.media.MediaFormat 班级概况 封装描述媒体数据格式的信息，无论是音频还是视频。媒体数据的格式被指定为字符串/值对。所有格式通用的键，所有未标记为可选的键都是必需的： 名称 ...
Android音频——AudioRecord和AudioTrack
逆流丿
01-04 925
一、基本参数说明 private final static int AUDIO_INPUT = MediaRecorder.AudioSource.MIC; private static final int mStreamType = AudioManager.STREAM_MUSIC; private final static int AUDIO_SAMPLE_RATE = 44100; private final static int AUDIO_CHANNEL = AudioFormat.CHAN
【Android -- 音频】音频数据的编解码
Kevin Learn Android
03-30 1088
本文重点关注如何对一帧音频数据进行编码和解码。
Android硬编码——音频编码、视频编码及音视频混合
湖广午王
01-04 1万+
视频编解码对许多Android程序员来说都是Android中比较难的一个知识点。在Android 4.1以前，Android并没有提供硬编硬解的API，所以之前基本上都是采用FFMpeg来做视频软件编解码的，现在FFMpeg在Android的编解码上依旧广泛应用。本篇博客主要讲到的是利用Android4.1增加的API MediaCodec和Android 4.3增加的API MediaMuxer
Android音视频开发（三）——MediaExtractor和MediaMuxer的使用
indeedes的博客
05-23 4740
了解了音视频的编解码过程，我们接下来使用一下经常跟MediaCodec一起搭配的MediaExtractor和MediaMuxer。最后会使用一个简单的demo来了解具体了解这两个工具类的使用过程。这一节我们就先不讲MediaCodec了，放到下节的demo。 一、MediaExtractor Android提供了一个MediaExtractor类，可以用来分离容器中的视频track和音频track。 主要API介绍： setDataSource(String path)：即可以设置本地文件又
android 录音 mp4,Android录音并且输出为Mp4文件的方法教程
weixin_39701288的博客
05-28 222
前言录音采用的是AudioRecord，通过MediaCodec进行编码，用MediaMuxer合成输出MP4文件。1.这里用AudioRecord来得到从麦克风录制的声音，AudiorRecord的用法还是比较简单的，首先初始化AudioRecordfun prepare(file: File?, outputFormat: Int = MediaMuxer.OutputFormat.MUXER...
Android 音视频编解码 MediaCodec
特立独行的博客
04-21 1917
Android中的MediaCodec是一个用于音视频编解码功能的API，使用它可以实现对音视频数据进行压缩、解压缩、编辑和转换。
Android audio音频流数据异常问题分析
m0_64420071的博客
08-30 2080
在 `Android` 系统的开发过程当中，音频异常问题通常有如下几类，无声，调节不了声音，爆音，声音卡顿，声音效果异常（忽大忽小，低音缺失等）等。尤其声音效果这部分问题通常从日志上信息量较少，相对难定位根因。...
Android MediaExtractor的使用（2）--提取aac音频
qq_15255121的专栏
07-27 734
MP4是一个封装格式，mp4包含视频流和音频流。大部分的音频流都是aac格式。那么我们现在来提取音频流。 使用到的api /** * Subsequent calls to {@link #readSampleData}, {@link #getSampleTrackIndex} and * {@link #getSampleTime} only retrieve information for the subset of tracks * selected.
Android MediaCodec硬解码AAC音频文件（实时AAC音频帧）并播放
君无意的博客
06-27 3522
今天在这里简单介绍一下，如何利用Android MediaCodec解码AAC音频文件或者实时AAC音频帧并通过AudioTrack来播放。主要的思路就是从文件或者网络获取一帧帧的AAC的数据，送入解码器解码后播放。
Android音视频合成工具-MediaMuxer
热门推荐
安卓开发&音视频开发
09-11 2万+
1️⃣、目标：把音视频流(使用各种通道传输过来的字节流)合成视频文件 2️⃣、工具：Android原生框架自带的MediaMuxer类 3️⃣、方案： private MediaMuxer mMuxer; ①MediaMuxer初始化 mMuxer = new MediaMuxer(“需要保存的路径”,MediaMuxer.OutputFormat.MUXER_OUTPUT_MPEG_4); ...
android 音视频硬编解码
KZax1l的博客
01-31 6448
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
使用MediaCodec编码AAC音频数据「第五章，Android音视频编码那点破事」
weixin_42277689的博客
08-08 877
 本章仅对部分代码进行讲解，以帮助读者更好的理解章节内容。 本系列文章涉及的项目HardwareVideoCodec已经开源到Github，支持软编和硬编。使用它你可以很容易的实现任何分辨率的视频编码，无需关心摄像头预览大小。一切都如此简单。目前已迭代多个稳定版本，欢迎查阅学习和使用，如有BUG或建议，欢迎Issue。   在上一章我们讲到了MediaCodec的工作流程，以及如何利用Med...
ALSA在Android音频系统中的应用与实现
7. **底层Audio驱动**：直接与硬件交互，执行音频数据的采集和回放，通常通过I2S或PCM接口与音频编解码器如ALC5625进行通信。 ALC5625是一款适用于此类设计的音频编解码器，集成了低功耗、高保真功能，支持多种输入...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值